From 0f8ba49f4a6082a46c977002ebf8919792667a13 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:12:09 -0400 Subject: [PATCH 01/77] Add RUST.md: the plan for moving the app to Rust Research and measurements from 2026-09-04: what the Compose app has to reproduce, why Android text input and rich selectable text decide the framework, the options considered (Masonry as the yardstick, iris as the in-house library to build up; Slint, iced, egui, Makepad rejected with reasons), how thin the Java shell can be, building the APK without Gradle, and the ordered experiments with pass conditions. Includes the emulator Vulkan findings: Venus is blocked by this emulator's gfxstream, SwiftShader over the emulator's own ICD works. Co-Authored-By: Claude Fable 5.1 --- AGENTS.md | 4 + RUST.md | 590 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 594 insertions(+) create mode 100644 RUST.md diff --git a/AGENTS.md b/AGENTS.md index a8991eb..af47340 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -46,6 +46,10 @@ Module-by-module intent is in PLAN.md's "Backend layout". before touching `TranscriptCache.kt`, `TranscriptSource.kt`, or the opening and stream effects in `SessionScreen.kt`. - `TODO.md` — the working list. +- `RUST.md` — the plan for moving the app to Rust (on the `rustify` + branch of the `ai-app-2` clone): what has to be reproduced, the + framework decision, and the ordered experiments with their pass + conditions. Read it before touching anything under that branch. - `.dev-updater.ron` — what Dev Updater builds here: the server (run as `service: Managed(…)`, supervised by Dev Updater's own implementation rather than a script kept here) and the APK, in parallel. It points at diff --git a/RUST.md b/RUST.md new file mode 100644 index 0000000..701e578 --- /dev/null +++ b/RUST.md @@ -0,0 +1,590 @@ +# Moving the app to Rust + +Working document for the question Iris asked on 2026-09-04: what are the +options for switching the phone app to Rust, ideally pure Rust with one UI +framework shared with a future winit-based desktop application, at full +feature parity and without giving up anything native, performance +especially. Constraints she set: no Dioxus and nothing that draws through a +WebView; **no UI DSL** (which rules out Makepad and Slint); the result +should stay lightweight; platform-specific pieces are fine to maintain; +reimplementing a framework piece from scratch where it does not fit is +fine; effort and elapsed time do not matter, long-term robustness does; +this clone is where things get tried before anything is committed to +`ai-app`. Her own library, [iris](https://github.com/cat16/iris), is the +**in-house framework to be built up** for this, with Masonry as the +yardstick it is measured against. + +Decisions get a date and a reason here, the way `PLAN.md` does. Nothing in +this file has been tried yet unless a section says it has. + +## What has to be reproduced + +The app is ~19,000 lines of Kotlin. It splits three ways, and the split is +what decides how much of a port is mechanical. + +**Pure logic with no Compose or Android in it, ~4,500 lines.** `Api.kt` +(1,142), `Events.kt`, `EventStream.kt`, `Sse.kt`, `TranscriptCache.kt` +(589, touches `java.io.File` only), `TranscriptSource.kt`, +`MarkdownSyntax.kt`, `Languages.kt`, `Highlighter.kt`, `Ansi.kt`, +`ResetCountdown.kt`, `Durations.kt`, `Sizes.kt`, `ModelName.kt`, +`LoadState.kt`, `ImportableStream.kt`. `TranscriptUnits.kt` and +`TranscriptItems.kt` (the event fold into rows, ~940 lines) are logic with +a handful of Compose annotations. This is also exactly the code that has +JVM unit tests today. All of it ports directly, and most of it already has a +Rust twin in `server/`: `Events.kt` is a hand-kept mirror of +`session/driver.rs`'s enum, the highlighter and the syntax scanner exist on +the server for the explorer, and the cache compares the server's own JSON +lines. **Sharing these types between server and app is the single largest +"keep things in sync" win available, and it does not depend on which UI +framework wins.** + +**Compose UI, ~13,000 lines.** Screens, dialogs, the transcript list, the +markdown renderer's customisations, tool cards, the file explorer viewer and +editor. This is the part a UI framework choice is about. + +**Android platform code, ~1,500 lines**, spread over 20 files. Every one of +these is a Java-side object that no Rust framework can replace, because +Android only offers them as Java classes: + +- `NotificationService` — a **foreground service** holding the + `/notifications` SSE stream while the app is closed, with its ongoing + notification, `specialUse` type and the `POST_NOTIFICATIONS` request. +- `MainActivity` — edge-to-edge, the `ACCESS_LOCAL_NETWORK` runtime + permission (Android 17), `singleTop` intent routing for `aiapp://enroll`, + notification taps, and the **share sheet** (`ACTION_SEND`, any MIME type). +- `ServerConfig` — the bearer token sealed under an **Android Keystore** + AES-GCM key, shared with Dev Updater through `wg-app-link`'s `:link`. +- `EnrollmentScanActivity` — the in-app **QR scanner** (zxing, camera). +- `Attachments` — `ContentResolver` reads of shared URIs, `BitmapFactory` + decode and downscale, **EXIF** orientation. +- `SessionImage` — bitmap decode for produced images. +- `ScrollAnchor`, `Drafts` — `SharedPreferences`; `CrashLog` — `filesDir`. +- `TranscriptCache` — `cacheDir`. +- `DebugStats`/`FrameStats` — `Choreographer` frame timing and the render + report; `runtime-tracing` names composables in a system trace. + +So **"pure Rust" on Android means Rust owns every line of logic and +drawing, behind a thin shell of Java stubs**, and a packaging step that +produces a signed APK. How thin, and whether Gradle is inevitable, are +answered below. + +### How much Java is unavoidable, and why + +Rust can *call* any Android API through JNI (`jni` crate, with +`ndk-context` handing over the `JavaVM` and the Activity): posting a +notification, `startForegroundService`, the Keystore, `ContentResolver` +reads, permission requests, `WindowInsets`, the clipboard. None of that +needs a line of Kotlin. What JNI cannot do is *define* a class that the +system instantiates **by name from the manifest** — an `Activity`, a +`Service`, an `Application`, a `BroadcastReceiver`. Those must exist as dex +bytecode inside the APK before any Rust runs, because the framework +constructs them and only then calls into native code. `NativeActivity` is +the platform's own stub for the Activity case; there is no +`NativeService`, and android-view ships its own `View` subclass for the +same reason. + +So the floor is roughly **two Java classes of ten lines each**: an +`Activity` and a `Service` whose lifecycle methods are declared `native` +and registered from `JNI_OnLoad`, plus whatever android-view already +provides. Everything they would have done in Kotlin — insets, intent +routing, the SSE follow loop, the notification builder — is Rust reached +through those stubs. Writing the stubs in Java rather than Kotlin drops +`kotlinc` from the toolchain; `javac` comes with the JDK Gradle already +needs. Generating the dex from Rust is not worth it: there is no mature +Rust dex writer, and the stubs never change. + +### Can the APK be built without Gradle? + +Yes. An APK is a zip containing a binary-XML `AndroidManifest.xml`, +`resources.arsc`, `classes.dex`, `lib//*.so` and assets, aligned and +signed with the v2 scheme. The tools are `aapt2` (manifest and resources), +`d8` (Java bytecode to dex), `zipalign` and `apksigner`, all in the SDK's +`build-tools`, none of them Gradle. Three ways to drive them: + +- **A `cargo xtask`** (or `build.rs`-adjacent script) that runs `cargo ndk` + for each ABI, `javac` + `d8` for the stubs, `aapt2 link`, `zipalign`, + `apksigner`. About 150 lines, every step visible, no AGP, no Gradle + daemon holding 2.8 GB between builds. The pinned-CA constant becomes a + `build.rs` reading the same `certs/ca.pem` path. +- **[cargo-apk2](https://github.com/mzdk100/cargo-apk2)**: the maintained + successor to cargo-apk, and unlike it compiles `java_sources` / + `kotlin_sources` into the dex and declares multiple activities **and + services** with intent filters from `[package.metadata.android]`, with + per-profile keystores and optional `aapt2`. Exactly the shape needed; + the question is whether a third-party tool with one maintainer beats + 150 lines we own. +- **cargo-apk / xbuild**: unmaintained and `NativeActivity`-only. No. + +What Gradle would take with it: Android Lint (which found two real bugs +here, but in Kotlin that would no longer exist — with forty lines of Java +stubs there is little left for it to find), manifest merging, R8, and the +generated-source plumbing. What it gives back: one toolchain, `cargo` +end to end, and Dev Updater keeps calling `build-apk.sh` exactly as now. +**Recommendation: the xtask**, with cargo-apk2 read for the details it +already got right (v2 signing, `uses-feature`, ABI splits). + +### The behaviours that are hard to get back + +Reading the Compose code for what a replacement must be able to express, +rather than what it happens to look like: + +1. **The transcript is one selectable body of text.** One + `SelectionContainer` around the whole lazy list, so a selection runs from + a reply into the tool output beneath it. The framework needs selectable + read-only rich text across many rows, with the platform's selection + handles and clipboard on the phone. +2. **Rich inline text**: markdown with links (one tap detector per text, + not a node per link), inline code chips drawn behind the text, tables + with wrapping cells and a sideways scroll, syntax-highlighted fences, + ANSI colour in tool output, Nerd Font icon glyphs. Needs a text layout + engine with spans, not just styled labels. +3. **A bottom-anchored virtualised list of variable-height rows**, paged in + both directions (800-event pages, `HISTORY_SCREENS` measured in + viewports), with a saved scroll anchor per session, "hold the edge + nearest the tap" when a row expands (`holdTopEdge`, done in the layout + pass so the wrong frame is never drawn), and rows keyed so that a run of + tool calls stays one row while it grows. +4. **The soft keyboard**: the composer resizes with the IME, the guard + against a stuck inset animation, drafts per session, autocorrect and + suggestions from the phone's own keyboard. This is where most Rust + frameworks fail on Android today; see below. +5. **Platform integration through the app model**: foreground service, + notifications, share sheet, deep link, Keystore, camera, back gesture, + edge-to-edge insets, local-network permission. +6. **Accessibility names on icon buttons**, which the bench scripts depend + on (`ui-trace` taps by label). A framework with no accessibility tree + also breaks the measuring rig. +7. **Measurable frames**: the debug render report, and a way to attribute + a frame's cost to a widget on the real phone. + +## The two constraints that decide it + +**1. Android text input.** Every framework built on `winit` inherits +winit's Android backend, and that backend cannot drive the soft keyboard +properly: the IME tracking issues +([#1823](https://github.com/rust-windowing/winit/issues/1823), +[#2766](https://github.com/rust-windowing/winit/issues/2766)) are open, +`ReceivedCharacter` is unimplemented on Android +([#2305](https://github.com/rust-windowing/winit/issues/2305)), and the +`android-activity` groundwork for editor actions only merged in February +2026 ([PR #214](https://github.com/rust-mobile/android-activity/pull/214)) +with the winit half still to come. Composition, autocorrect and suggestions +need an `InputConnection` implemented on the Java side, which winit's +`NativeActivity`/`GameActivity` model does not offer. The frameworks that +type on Android today each wrote their own Java glue (Slint, Makepad), and +the one designed to do it the way Android intends is +[`android-view`](https://github.com/rust-mobile/android-view): a Rust +implementation of an Android `View`, with text input through +`InputConnection`, accessibility, touch, callbacks on the UI thread, usable +either as a whole app or embedded beside ordinary Android components. It is +marked WIP. Both Linebender (its Masonry demo lives in that repo) and +Robius/Makepad ([Robrix's release notes](https://github.com/project-robius/robrix/releases) +say Android lacks a "full" keyboard and they are integrating android-view +for it) are converging on it. **That makes android-view the phone-side +foundation whichever widget set sits on top**, and the first thing to +build and measure here. + +**2. Rich, selectable text and a virtualised list.** Frameworks group by +their text stack: + +- **Parley + Fontique + Vello** (Linebender): rich spans, selection and + editing utilities, IME support driven through `ui-events`, AccessKit text + properties ([Linebender 2026 Q1](https://linebender.org/blog/tmil-25/), + [parley](https://github.com/linebender/parley)). Used by Masonry/Xilem, + and by Blitz. Vello proper needs compute shaders; `vello_hybrid` (CPU + path processing, GPU compositing) is "roughly beta" and runs on GLES too, + and Vello CPU exists as a no-GPU fallback. +- **cosmic-text** (iced, egui optionally): good layout, but the widgets on + top decide selection. iced's `markdown` widget is not selectable + ([discourse](https://discourse.iced.rs/t/markdown-widgets-text-should-be-selectable/1107)). +- **Slint's own**: `TextInput` with `read-only` is the selectable-text + trick; there is **no inline rich text at all** (issue + [#1325](https://github.com/slint-ui/slint/issues/1325), markdown request + [#6684](https://github.com/slint-ui/slint/issues/6684) both open). A + markdown transcript with links and code chips cannot be drawn. +- **Makepad's own**: GPU/SDF text, a `Markdown` widget and a virtualised + `PortalList` in `makepad-widgets`. + +## Options + +### A. Keep Compose, move the logic into a Rust core (uniffi) + +A `client-core` crate (events shared with the server, API client, SSE, +transcript fold, cache, markdown model, highlighter, ANSI) exposed to +Kotlin through [uniffi](https://github.com/mozilla/uniffi-rs). Compose keeps +drawing. Desktop would be a second UI (iced or Compose Desktop) over the +same core. + +- **For**: the logic and the wire types stop drifting from the server + today, with tests in one language. Incremental and always shippable. +- **Against**: it is not what was asked for. The 13,000 lines of UI stay + Kotlin, the desktop app shares no UI code, and the `:link` Kotlin module + stays. uniffi's Kotlin Multiplatform bindings are a + [community fork](https://github.com/UbiqueInnovation/uniffi-kotlin-multiplatform-bindings); + the Android-only bindings are Mozilla's and solid. +- **Verdict**: not the destination, but **step one of every other option** + is building this crate, so it costs nothing to keep it as the fallback. + +### B. Slint + +Rust on Android is officially supported (minSdk 26, `android-activity` +backend, own Java IME glue, safe areas and keyboard insets since 1.15, +Skia renderer needs `clang`). Royalty-free licence requires disclosing +Slint use; GPLv3 otherwise. UI is a separate `.slint` DSL, not Rust. + +- **Against**: no rich inline text (see above), so the transcript cannot be + drawn as it is today; the UI language is not Rust, which forfeits the + "compiler catches it" motivation for the half of the code that is UI. +- **Verdict**: rejected on rich text alone. + +### C. iced + +Elm-style, Rust-only widgets, desktop-first, `winit` + `wgpu`. Has a +`markdown` widget and `rich_text` with links. The maintainer states mobile +is a non-goal ([iced](https://github.com/iced-rs/iced)); a community +Android example exists and its author could not get the soft keyboard +working, patched widgets for touch, and notes no accessibility +([HN thread](https://news.ycombinator.com/item?id=46350641)). Markdown is +not selectable; `scrollable` is not virtualised. + +- **Verdict**: a fine desktop toolkit and the one Iris named, but every + phone-side gap (IME, touch, accessibility, selection, virtualisation) + would be ours to build and maintain against a project that does not want + them. Not the shared framework. + +### D. egui + +Immediate mode, `winit`-based on Android, AccessKit integration, +selectable labels across a `Ui`. Repaints only on input by default, so +battery is not the immediate-mode worry. Android IME is blocked on winit +([discussion](https://github.com/emilk/egui/discussions/2053)); the +workaround is an in-app virtual keyboard, which is exactly the +non-native keyboard to avoid. Variable-height virtualised lists are manual +(`show_rows` assumes uniform heights). Looks like egui, not Material. + +- **Verdict**: workable on desktop, wrong on the phone for the same reason + as iced, plus a look that would need a full custom style. + +### E. Makepad + +GPU-rendered, hybrid retained/immediate, `live_design!` DSL with hot +reload, MIT, 1.0 in 2025 ([makepad](https://github.com/makepad/makepad)). +Ships Android apps today with its own Java glue; Robrix (a Matrix chat +client, the closest analogue to this app) is its reference application on +Android, iOS and desktop. Has `Markdown`, `PortalList` (virtualised), +`TextInput`. Robrix reports the Android keyboard is not "full" and is moving +to android-view for it; the README says non-standard targets "may require +minor fixes". + +- **For**: the only option that already ships a chat-shaped app on Android + and desktop from one codebase, with the widgets this app needs. +- **Against**: the DSL is its own language with its own shader-based + styling, so a large part of the UI would not be checked by rustc; the + rendering model (SDF everything) is a different world from Compose's, + and selection across a `Markdown` widget is unverified. +- **Verdict**: **rejected 2026-09-04** — Iris does not want a DSL. Kept + here so its Android keyboard status stays a data point about + android-view, not as an option. + +### F. Masonry / Xilem on android-view (Linebender) + +Retained widget tree (Masonry) with a reactive view layer (Xilem) that +reads like Compose; Rust all the way down; Vello, Parley, Fontique, +AccessKit, `ui-events`. Widgets include `Prose` (selectable read-only rich +text), `TextArea`, `VirtualScroll`, and this year `Svg`, `Split`, +`CollapsePanel`, a new layout system, and IME through `ui-events` +independent of winit. `masonry_android_view` exists in the android-view +repo and is "not yet generally usable"; Xilem calls itself experimental. +Desktop runs on winit. Vello needs a compute-capable GPU or falls back to +`vello_hybrid`/CPU. + +- **For**: the only stack where every hard behaviour above maps onto a + component designed for it: selection and rich text (Parley/Prose), + virtualised variable heights (`VirtualScroll`), native IME + (android-view's `InputConnection`), accessibility (AccessKit, now with an + Android crate), one Rust widget language on both platforms. The team is + the one writing the Android integration everyone else is adopting. +- **Against**: pre-1.0 with API churn each release; a small team; no + Material widget set, so every control's look is ours; some of the pieces + (`masonry_android_view`, `vello_hybrid`) are explicitly unfinished. Being + early means fixing things upstream ourselves, which Iris said is + acceptable. +- **Verdict**: **the option to try first**, because it is the only one + whose gaps are "not finished yet" rather than "not designed for this". + +### G. iris — the in-house library, and what "from scratch" means here + +[cat16/iris](https://github.com/cat16/iris), read 2026-09-04 from the one +public commit (2026-01-31, "portfolio copy"; ~8,700 lines in `core`, +`macro` and the crate itself). Retained-mode widgets stored outside the +render tree, `wgpu` 28 directly, `winit` 0.30, `cosmic-text` 0.16, a +relative-anchor-plus-offset layout with `rest()` and `rel()` lengths, a +postfix builder API (`rect(..).radius(30).on(CursorSense::click(), ..) +.sized(..).align(..)`), events handled where the widget is declared, and +a single-threaded context passed explicitly — all of which reads like this +codebase's own rules. There is text editing (`widget/text/edit.rs`), +images, masks, spans and stacks; the TODO names text resizing as +per-frame slow and scaling as unsolved. It requires **nightly** (fourteen +`#![feature]` gates, among them `const_trait_impl`, `unboxed_closures`, +`portable_simd`, `associated_type_defaults`). Desktop only; no Android +surface, no IME, no accessibility tree, no virtualised list, no rich-text +selection. + +**iris is not a candidate to be tested as it stands. It is the in-house +library** (Iris, 2026-09-04): "essentially a good start to a rewrite from +scratch", to be maintained and extended by the sessions working here. +So the list above of what it lacks is a **work list, not a score**. When +the app needs something iris does not have, the answer is to build it +into iris. The layer iris has is the widget and layout layer; the layers +it needs are the same ones Masonry gets from android-view, Parley and +AccessKit, and there is no reason iris cannot sit on those same +foundations rather than reinvent them — the surface, the keyboard bridge +and the accessibility tree are platform plumbing, not a framework's +identity. Whether the text stack stays cosmic-text or moves to Parley is +the first real design decision in that work (see I1 below). + +Two things to carry into that work honestly. Nightly is the opposite of +"holds up long term": a build that breaks on a toolchain update, on the +machine Dev Updater builds on, unattended. Pin a dated nightly in +`rust-toolchain.toml` immediately, and keep a list of which `#![feature]` +gates are load-bearing so they can be retired as they stabilise or are +designed around. And a one-person framework carries every gap itself, +which is what Iris said she is willing to do. + +"From scratch" therefore means iris, not a fourth thing. Masonry stays in +the plan as the **yardstick and the fallback**: building its demo and its +version of the transcript screen first says what a finished stack costs +on this hardware, proves android-view before iris depends on it, and +gives a comparison that is measured rather than remembered. + +Not considered further: **GPUI** (Zed) mobile is a community fork that +depends on unpublished crates; **Dioxus/Blitz** is excluded by Iris (its +native renderer is Parley/Vello under HTML semantics, and the earlier +`tdep-survey/app-dioxus` spike parked it on a `vello_hybrid` stroke bug and +shipped the WebView); **Compose Multiplatform Desktop** would give a desktop +app for nothing but in Kotlin, which is the opposite direction. + +### Weight and debug builds + +Iris remembers the Linebender stack being slow in debug. What is behind +that is the dependency graph — Vello, wgpu, Parley, Fontique, Skrifa — +running unoptimised on the CPU side (path encoding, shaping), not the +widget layer. Xilem's own advice is only `split-debuginfo = "unpacked"` to +keep `target/` small; the fix everyone with this shape of dependency tree +uses is to optimise dependencies while leaving the app crate at `opt-level += 0`: + + [profile.dev.package."*"] + opt-level = 2 + +E1 measures this rather than remembering it: cold and incremental build +time, APK size, resident memory at rest and while streaming, and the +frame cost of one 800-event page — for the Masonry demo as shipped, then +with the profile above. Vello proper needs compute shaders and carries a +large shader set; `vello_hybrid` is lighter and Masonry can now render +through either (or Vello CPU) via its `imaging` abstraction, so "keep it +light" has a knob inside the same stack. + +## Recommendation + +1. **Build `client-core` now, whatever the framework.** A Rust crate holding + the event model (shared with `server/` as one crate, ending the + `Events.kt` mirror), the API and SSE clients, the transcript fold, the + cache, the markdown block model, the highlighter and the ANSI parser, + with the existing JVM tests ported. It is the part of the app that is + already tested, already logic, and already duplicated on the server. +2. **One foundation, two widget layers.** The platform plumbing is shared + whichever way the decision goes: android-view for the Android surface, + keyboard and accessibility bridge; `wgpu` for the GPU; AccessKit for + names; winit on the desktop. On top of it, **Masonry as the yardstick** + (E1, E2) and **iris as the thing being built** (I0–I5), both aimed at + the same transcript screen with the same pass conditions. +3. **Decide when the transcript screen exists in both**, from the + measurements, and record the decision here with the numbers. If iris + carries the screen within the Compose baseline, it is the app's + framework and Masonry was the calibration. If it does not, the + measurement says which parts of Masonry to adopt underneath it. +4. Then the shell (E3), the desktop window (E4) and the packaging (E5), + which do not depend on the choice. + +## Experiments, in order + +Each has a pass condition that is a measurement in this clone. The rig +matters: this emulator runs `-gpu host` with **host Vulkan switched off** +(`GPU_HOST_FEATURES` in `emulator-tools`, a gfxstream/Venus gap), so inside +the guest a `wgpu` app gets GLES, not Vulkan; the earlier Dioxus spike also +needed `WGPU_GLES_MINOR_VERSION=1` for compute shaders and found `wgpu`'s +Android backend wants API 26 (a libc symbol). The real phone has Vulkan. +Per the standing rule, a rig limit is something to fix before it is +accepted. + +- [ ] **E0 — toolchain.** No NDK is installed (`~/Android/Sdk/ndk` is + empty; the Android Rust targets are). Install the NDK under the + user-owned SDK, `cargo-ndk`, and record the versions here. +- [ ] **E1 — android-view's Masonry demo on this emulator.** Pass: it + builds with `cargo-ndk` + Gradle, renders on the GPU, and the phone's + own keyboard types into its editor with autocorrect and suggestions. + Note which `wgpu` backend it took and any environment flags needed. +- [ ] **E2 — a transcript in Masonry.** One screen: open a sandbox session, + page 800 events into `VirtualScroll` bottom-anchored, draw markdown + from `pulldown-cmark` into Parley rich text with links and code + chips, select across two rows with the platform handles, expand a + tool row holding its top edge. Pass: the render numbers land within + the Compose baseline in `transcript-bench.sh` on the GPU emulator + (same gestures, same session), and every one of the seven behaviours + above is either shown or has a written reason it cannot be. +- [ ] **E3 — the shell.** Kotlin `MainActivity` + `NotificationService` + + Keystore + share intent calling into Rust over JNI, with the SSE + follow loop in Rust. Pass: a notification arrives with the app + closed, and a share lands in a session. +- [ ] **E4 — the same screen on the desktop** in a winit window, from the + same crate, with only the layout differing. +- [ ] **E5 — the packaging xtask**: `cargo ndk` → `javac`/`d8` → `aapt2` + → `zipalign` → `apksigner`, signed with the existing release key, + installed through Dev Updater. Pass: the APK installs over the + Gradle-built one and the notification service starts. + +### The iris track + +These build iris up to carry the app. Each is a feature added to iris +with a pass condition, in dependency order. Work in iris's own repository, +pinned here by commit, and record in this file what each step measured. + +- [ ] **I0 — bring iris in-house.** Decide where it lives — the + recommendation is a repository of its own on the gitea remote, + consumed here the way `wg-app-link` is (a submodule pinned to a + commit), so the app and the library version-lock and the library + stays usable by the desktop app on its own. Pin a dated nightly in + `rust-toolchain.toml`; list every `#![feature]` gate with what it is + for, so each can be retired when it stabilises. Get `cargo build`, + `clippy` and `fmt` clean at the defaults and the `tabs` example + running in a window. Pass: a fresh clone builds unattended from the + pinned toolchain. +- [ ] **I1 — the text stack decision.** iris uses cosmic-text; the + transcript needs rich inline spans (links, code chips, colour), + selection across many widgets with the platform's handles on the + phone, and an editor the IME can drive (composition regions, not + just committed characters). Compare cosmic-text and Parley against + exactly those three, in iris, on a real transcript's text. Parley + is the expectation because android-view's IME bridge and AccessKit's + text properties are written against it; measure rather than assume. + Pass: a written decision here with what each was tried on, and the + TODO's "text resizing per frame is really slow" measured and either + fixed or explained. +- [ ] **I2 — iris on android-view.** An `android-view` surface as a second + backend beside winit: `wgpu` on the view's surface (GLES here, see + the Vulkan section; Vulkan on the phone), touch as pointer events, + window insets and the keyboard inset as layout inputs, the back + gesture as an event, the IME bridge feeding the editor from I1. + Pass: the `tabs` example and a text field run on the emulator, and + the phone's own keyboard types into the field with autocorrect and + suggestions — the same bar as E1. +- [ ] **I3 — a virtualised, bottom-anchored list.** Variable-height rows, + keyed, composed only while visible, paged in both directions with a + "more" sentinel at each end, a scroll anchor that survives rows + being inserted above, and "hold the edge nearest the tap" done in + the layout pass. Pass: 800 rows of real transcript text from the + sandbox scroll without a frame over the Compose baseline in + `transcript-bench.sh`, measured on the GPU emulator. +- [ ] **I4 — accessibility names via AccessKit.** Every control carries a + name; `ui-trace` can find and tap it by label. Pass: `bench-lib.sh`'s + tap-by-name works against the iris screen unchanged. +- [ ] **I5 — the transcript screen in iris.** E2's pass conditions, all + seven behaviours, against the sandbox with `--delay`. This is the + point the decision in the recommendation is made at. + +## For the next agent + +What to do when you pick this up, in order, so nothing here has to be +re-derived: + +1. Read this file, then `AGENTS.md` and `PLAN.md`. The rules there + (measure, do not read; fix the rig before accepting its limits; the + emulator is this checkout's own) all apply. +2. Work on the **`rustify`** branch of this clone (`ai-app-2`), not on + `main` and not in `ai-app`. Nothing on this branch is production until + Iris says so. Commit and push as you go. +3. Take the next unchecked box above, in order: E0 first, then E1, then + the iris track from I0. E-steps and I-steps can proceed in parallel in + separate sessions once E1 has proved android-view on this emulator. +4. Every step ends with its measurement written into this file beside the + box, and the box ticked or the reason it could not be written in its + place. A step that is blocked says by what, not "later". +5. Run the existing rigs rather than inventing new ones: `ui-sandbox.sh` + for a server with fixtures, `transcript-bench.sh` for the scroll + baseline, `ui-trace` for anything positional, `emu up` for the + emulator. The Vulkan section below says how to get a Vulkan path in the + emulator when a `wgpu` backend needs one. +6. Decisions belong here with a date and what was rejected, the way + `PLAN.md` does it. Do not put design into commit messages alone. + +### Vulkan in the emulator (measured 2026-09-04) + +A `wgpu` app in this emulator was going to get GLES only, because host +Vulkan is switched off in `emulator-tools`. Retried today on Mesa +26.1.7: **Venus still fails the same way** — gfxstream picks +`externalMemoryMode: OpaqueFd`, probes `VK_FORMAT_R8G8B8A8_UNORM` for an +exportable colour buffer, and Venus says the format is unsupported +(`Failed to find memory type for ColorBuffers`, fatal before adb sees the +device). Venus does advertise `VK_KHR_external_memory_fd` and +`VK_EXT_external_memory_dma_buf`, so the gap is specifically opaque-fd +image export. gfxstream has a string-valued `VulkanExternalMemoryMode` +setting ("overrides what would otherwise be determined automatically"), +but `-feature Name=Value` is rejected as a bad feature name, and the only +mode words compiled into this emulator's `libgfxstream_backend.so` +(37.1.11) are `OpaqueFd`, `Metal` and `none` — there is no dma-buf mode +in this build to switch to. So Venus is blocked by the emulator, not by +Mesa; retry when the emulator package updates, since upstream gfxstream +does have dma-buf external memory. + +What **does** work: pointing the emulator's Vulkan loader at the software +ICDs the emulator ships itself, with the feature enabled: + + VK_DRIVER_FILES=$HOME/Android/Sdk/emulator/lib64/vulkan/vk_swiftshader_icd.json \ + GPU_HOST_FEATURES="-feature Vulkan" emu up + +The guest then reports Vulkan 1.3 (`cmd gpu vkjson`, SwiftShader +Subzero) while GLES still runs on the real GPU through virgl — so a +Vello/wgpu app can take its real Vulkan path here, with compute shaders, +CPU-rasterised. That is enough to test *correctness* of the Vulkan path +in the emulator; GPU *performance* of it is a phone measurement either +way, exactly as `MACHINE.md` already says about frame times. **lavapipe** +(`lvp_icd.json`, the other ICD the emulator ships) selected llvmpipe and +booted, then the emulator died right after loading the `default_boot` +snapshot with nothing in the log; a snapshot saved under a different +Vulkan device is the suspect, and `-no-snapshot-load` is the untested +next step. SwiftShader is the one that works today. +Making this an `emu` option belongs in `emulator-tools` and is a shared +tooling change, so it goes through the other sessions first. + +## Things a Rust app changes elsewhere + +- **`wg-app-link`'s `:link`** (pinned TLS, enrollment store, QR activity) + is Kotlin shared with Dev Updater. The certificate code already exists on + the Rust side of the submodule; the pinned-CA build step + (`generatePinnedCert`) becomes a `build.rs` reading the same path. The QR + scanner stays a Kotlin activity, since the camera is a platform feature. +- **Tooling** becomes `cargo` for everything but packaging: `cargo test`, + `clippy`, `fmt` cover the whole client, which is the motivation. Gradle + remains for the APK, signing (`~/.config/ai-app/release.jks`) and Dev + Updater's build modes; `build-apk.sh` would call `cargo ndk` first. +- **The bench scripts** (`ui-trace` by accessibility label) keep working + only if the framework exposes names through AccessKit on Android; that is + part of E2's pass condition, not a nicety. +- **Icons** stay Nerd Font glyphs from the committed subset; Parley/Fontique + loads a font file directly, so `build-icon-font.sh` is unchanged. + +## Sources + +- iced: [repo](https://github.com/iced-rs/iced), [0.14 release](https://github.com/iced-rs/iced/releases/tag/0.14.0), [Android thread](https://news.ycombinator.com/item?id=46350641), [markdown selection request](https://discourse.iced.rs/t/markdown-widgets-text-should-be-selectable/1107) +- Linebender: [2026 Q1 report](https://linebender.org/blog/tmil-25/), [xilem](https://github.com/linebender/xilem), [parley](https://github.com/linebender/parley), [vello](https://github.com/linebender/vello), [vello_hybrid](https://docs.rs/vello_hybrid/latest/vello_hybrid/) +- android-view: [repo](https://github.com/rust-mobile/android-view); android-activity [PR #214](https://github.com/rust-mobile/android-activity/pull/214) +- winit Android IME: [#1823](https://github.com/rust-windowing/winit/issues/1823), [#2766](https://github.com/rust-windowing/winit/issues/2766), [#2305](https://github.com/rust-windowing/winit/issues/2305) +- egui on Android: [discussion #2053](https://github.com/emilk/egui/discussions/2053) +- Slint: [Android guide](https://docs.slint.dev/latest/docs/slint/guide/platforms/mobile/android/), [1.15 release](https://slint.dev/blog/slint-1.15-released), [licensing](https://slint.dev/faqs), rich text [#1325](https://github.com/slint-ui/slint/issues/1325), markdown [#6684](https://github.com/slint-ui/slint/issues/6684) +- Makepad: [repo](https://github.com/makepad/makepad), [makepad-widgets](https://docs.rs/makepad-widgets), [Robrix](https://github.com/project-robius/robrix), [Robrix releases](https://github.com/project-robius/robrix/releases) +- AccessKit: [releases](https://github.com/AccessKit/accesskit/releases) +- Build tools: [cargo-ndk](https://github.com/bbqsrc/cargo-ndk), [cargo-apk](https://github.com/rust-mobile/cargo-apk), [rust-mobile](https://github.com/rust-mobile) +- uniffi: [repo](https://github.com/mozilla/uniffi-rs), [KMP bindings fork](https://github.com/UbiqueInnovation/uniffi-kotlin-multiplatform-bindings) +- GPUI mobile: [gpui-mobile](https://github.com/itsbalamurali/gpui-mobile) +- The earlier Dioxus spike's findings on `wgpu`/Vulkan in this emulator: `~/repos/tdep-survey/app-dioxus/README.md` From 4ab26f068ecdaca55cd206b5f2d05aa0140663f9 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:17:16 -0400 Subject: [PATCH 02/77] Vendor iris, the in-house UI library, at iris/ Iris's decision: it lives in this repository for now, included by path, with its history left in the iris/iris repository on the gitea remote (this is its main at 7b54aaf, byte-identical to the public GitHub copy). It gets its own repository back once it has proved itself here. RUST.md's I0 records the decision and what the first build said: the tree does not compile on the current nightly because const_trait_impl now requires traits to be declared 'const trait', which is the first item of I0b. Co-Authored-By: Claude Fable 5.1 --- .gitignore | 3 + RUST.md | 45 +- iris/.gitignore | 2 + iris/Cargo.lock | 3635 +++++++++++++++++++++++++ iris/Cargo.toml | 42 + iris/TODO | 40 + iris/core/Cargo.toml | 12 + iris/core/src/attr.rs | 23 + iris/core/src/event/ctx.rs | 18 + iris/core/src/event/manager.rs | 157 ++ iris/core/src/event/mod.rs | 44 + iris/core/src/event/rsc.rs | 34 + iris/core/src/lib.rs | 36 + iris/core/src/num.rs | 49 + iris/core/src/orientation/align.rs | 200 ++ iris/core/src/orientation/axis.rs | 115 + iris/core/src/orientation/len.rs | 198 ++ iris/core/src/orientation/mod.rs | 11 + iris/core/src/orientation/pos.rs | 464 ++++ iris/core/src/primitive/color.rs | 163 ++ iris/core/src/primitive/layer.rs | 275 ++ iris/core/src/primitive/mod.rs | 9 + iris/core/src/primitive/text.rs | 191 ++ iris/core/src/primitive/texture.rs | 136 + iris/core/src/render/data.rs | 50 + iris/core/src/render/mod.rs | 362 +++ iris/core/src/render/primitive.rs | 282 ++ iris/core/src/render/shader.wgsl | 178 ++ iris/core/src/render/texture.rs | 129 + iris/core/src/render/util/mod.rs | 48 + iris/core/src/ui/active.rs | 14 + iris/core/src/ui/cache.rs | 18 + iris/core/src/ui/mod.rs | 47 + iris/core/src/ui/painter.rs | 145 + iris/core/src/ui/render_state.rs | 319 +++ iris/core/src/ui/size.rs | 86 + iris/core/src/util/arena.rs | 109 + iris/core/src/util/borrow.rs | 35 + iris/core/src/util/change.rs | 30 + iris/core/src/util/id.rs | 87 + iris/core/src/util/math.rs | 87 + iris/core/src/util/mod.rs | 24 + iris/core/src/util/refcount.rs | 36 + iris/core/src/util/slot.rs | 69 + iris/core/src/util/trust.rs | 17 + iris/core/src/util/typemap.rs | 56 + iris/core/src/util/vec2.rs | 99 + iris/core/src/widget/data.rs | 22 + iris/core/src/widget/handle.rs | 164 ++ iris/core/src/widget/like.rs | 75 + iris/core/src/widget/mod.rs | 87 + iris/core/src/widget/tag.rs | 64 + iris/core/src/widget/view.rs | 24 + iris/core/src/widget/widgets.rs | 145 + iris/examples/minimal.rs | 21 + iris/examples/tabs/assets/sungals.png | Bin 0 -> 8911 bytes iris/examples/tabs/main.rs | 225 ++ iris/examples/task.rs | 34 + iris/examples/view.rs | 53 + iris/macro/Cargo.toml | 12 + iris/macro/src/lib.rs | 196 ++ iris/readme.md | 31 + iris/src/default/app.rs | 60 + iris/src/default/attr.rs | 78 + iris/src/default/event.rs | 9 + iris/src/default/input.rs | 78 + iris/src/default/mod.rs | 354 +++ iris/src/default/render.rs | 144 + iris/src/default/sense.rs | 308 +++ iris/src/default/state.rs | 75 + iris/src/default/task.rs | 82 + iris/src/event.rs | 87 + iris/src/lib.rs | 26 + iris/src/widget/event.rs | 0 iris/src/widget/image.rs | 55 + iris/src/widget/mask.rs | 20 + iris/src/widget/mod.rs | 15 + iris/src/widget/position/align.rs | 35 + iris/src/widget/position/layer.rs | 23 + iris/src/widget/position/max_size.rs | 48 + iris/src/widget/position/mod.rs | 19 + iris/src/widget/position/offset.rs | 21 + iris/src/widget/position/pad.rs | 134 + iris/src/widget/position/scroll.rs | 66 + iris/src/widget/position/sized.rs | 34 + iris/src/widget/position/span.rs | 207 ++ iris/src/widget/position/stack.rs | 80 + iris/src/widget/ptr.rs | 57 + iris/src/widget/rect.rs | 51 + iris/src/widget/text/build.rs | 147 + iris/src/widget/text/edit.rs | 631 +++++ iris/src/widget/text/mod.rs | 203 ++ iris/src/widget/trait_fns.rs | 148 + 93 files changed, 12665 insertions(+), 12 deletions(-) create mode 100644 iris/.gitignore create mode 100644 iris/Cargo.lock create mode 100644 iris/Cargo.toml create mode 100644 iris/TODO create mode 100644 iris/core/Cargo.toml create mode 100644 iris/core/src/attr.rs create mode 100644 iris/core/src/event/ctx.rs create mode 100644 iris/core/src/event/manager.rs create mode 100644 iris/core/src/event/mod.rs create mode 100644 iris/core/src/event/rsc.rs create mode 100644 iris/core/src/lib.rs create mode 100644 iris/core/src/num.rs create mode 100644 iris/core/src/orientation/align.rs create mode 100644 iris/core/src/orientation/axis.rs create mode 100644 iris/core/src/orientation/len.rs create mode 100644 iris/core/src/orientation/mod.rs create mode 100644 iris/core/src/orientation/pos.rs create mode 100644 iris/core/src/primitive/color.rs create mode 100644 iris/core/src/primitive/layer.rs create mode 100644 iris/core/src/primitive/mod.rs create mode 100644 iris/core/src/primitive/text.rs create mode 100644 iris/core/src/primitive/texture.rs create mode 100644 iris/core/src/render/data.rs create mode 100644 iris/core/src/render/mod.rs create mode 100644 iris/core/src/render/primitive.rs create mode 100644 iris/core/src/render/shader.wgsl create mode 100644 iris/core/src/render/texture.rs create mode 100644 iris/core/src/render/util/mod.rs create mode 100644 iris/core/src/ui/active.rs create mode 100644 iris/core/src/ui/cache.rs create mode 100644 iris/core/src/ui/mod.rs create mode 100644 iris/core/src/ui/painter.rs create mode 100644 iris/core/src/ui/render_state.rs create mode 100644 iris/core/src/ui/size.rs create mode 100644 iris/core/src/util/arena.rs create mode 100644 iris/core/src/util/borrow.rs create mode 100644 iris/core/src/util/change.rs create mode 100644 iris/core/src/util/id.rs create mode 100644 iris/core/src/util/math.rs create mode 100644 iris/core/src/util/mod.rs create mode 100644 iris/core/src/util/refcount.rs create mode 100644 iris/core/src/util/slot.rs create mode 100644 iris/core/src/util/trust.rs create mode 100644 iris/core/src/util/typemap.rs create mode 100644 iris/core/src/util/vec2.rs create mode 100644 iris/core/src/widget/data.rs create mode 100644 iris/core/src/widget/handle.rs create mode 100644 iris/core/src/widget/like.rs create mode 100644 iris/core/src/widget/mod.rs create mode 100644 iris/core/src/widget/tag.rs create mode 100644 iris/core/src/widget/view.rs create mode 100644 iris/core/src/widget/widgets.rs create mode 100644 iris/examples/minimal.rs create mode 100755 iris/examples/tabs/assets/sungals.png create mode 100644 iris/examples/tabs/main.rs create mode 100644 iris/examples/task.rs create mode 100644 iris/examples/view.rs create mode 100644 iris/macro/Cargo.toml create mode 100644 iris/macro/src/lib.rs create mode 100644 iris/readme.md create mode 100644 iris/src/default/app.rs create mode 100644 iris/src/default/attr.rs create mode 100644 iris/src/default/event.rs create mode 100644 iris/src/default/input.rs create mode 100644 iris/src/default/mod.rs create mode 100644 iris/src/default/render.rs create mode 100644 iris/src/default/sense.rs create mode 100644 iris/src/default/state.rs create mode 100644 iris/src/default/task.rs create mode 100644 iris/src/event.rs create mode 100644 iris/src/lib.rs create mode 100644 iris/src/widget/event.rs create mode 100644 iris/src/widget/image.rs create mode 100644 iris/src/widget/mask.rs create mode 100644 iris/src/widget/mod.rs create mode 100644 iris/src/widget/position/align.rs create mode 100644 iris/src/widget/position/layer.rs create mode 100644 iris/src/widget/position/max_size.rs create mode 100644 iris/src/widget/position/mod.rs create mode 100644 iris/src/widget/position/offset.rs create mode 100644 iris/src/widget/position/pad.rs create mode 100644 iris/src/widget/position/scroll.rs create mode 100644 iris/src/widget/position/sized.rs create mode 100644 iris/src/widget/position/span.rs create mode 100644 iris/src/widget/position/stack.rs create mode 100644 iris/src/widget/ptr.rs create mode 100644 iris/src/widget/rect.rs create mode 100644 iris/src/widget/text/build.rs create mode 100644 iris/src/widget/text/edit.rs create mode 100644 iris/src/widget/text/mod.rs create mode 100644 iris/src/widget/trait_fns.rs diff --git a/.gitignore b/.gitignore index d3f8a85..84242cd 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,6 @@ certs/ config.ron config.json sessions/ + +# iris, the in-house UI library, is vendored at iris/ and built by cargo. +iris/target/ diff --git a/RUST.md b/RUST.md index 701e578..202bd03 100644 --- a/RUST.md +++ b/RUST.md @@ -447,19 +447,40 @@ accepted. ### The iris track These build iris up to carry the app. Each is a feature added to iris -with a pass condition, in dependency order. Work in iris's own repository, -pinned here by commit, and record in this file what each step measured. +with a pass condition, in dependency order. Work in `iris/` in this +repository on the `rustify` branch, and record in this file what each +step measured. -- [ ] **I0 — bring iris in-house.** Decide where it lives — the - recommendation is a repository of its own on the gitea remote, - consumed here the way `wg-app-link` is (a submodule pinned to a - commit), so the app and the library version-lock and the library - stays usable by the desktop app on its own. Pin a dated nightly in - `rust-toolchain.toml`; list every `#![feature]` gate with what it is - for, so each can be retired when it stabilises. Get `cargo build`, - `clippy` and `fmt` clean at the defaults and the `tabs` example - running in a window. Pass: a fresh clone builds unattended from the - pinned toolchain. +- [x] **I0a — where iris lives (decided 2026-09-04).** For now it is + **vendored at `iris/` in this repository**, history not carried, + and consumed by path. Iris's decision: keep it close while it is + being reshaped for this app, and give it back its own repository — + `iris/iris` on the gitea remote, which already holds the full + 244-commit history, on a branch of its own — once it has proved + itself. The vendored tree is that repository's `main` at + `7b54aaf` ("readme", 2026-01-29), byte-identical to the public + GitHub copy, so a later reconciliation has a known base. A crate + that uses it says `iris = { path = "../iris" }`. +- [ ] **I0b — make it build here.** Pin a dated nightly in + `iris/rust-toolchain.toml` (the machine has + `nightly-x86_64-unknown-linux-gnu`, rustc 1.100.0-nightly + 2026-08-25); list every `#![feature]` gate with what it is for, so + each can be retired when it stabilises. Get `cargo build`, `clippy` + and `fmt` clean at the defaults and the `tabs` example running in a + window (this VM has no display: a headless compositor is what + `emu` uses for the emulator, and the same trick serves here). + Pass: a fresh clone builds unattended from the pinned toolchain. + **Measured 2026-09-04**: `cargo +nightly check` on that nightly + fails in `iris-core` with 36 errors, all one cause — the + `const_trait_impl` feature changed shape between January and + August: `impl const Trait for T` is now rejected with "expected a + trait, found type" unless the trait itself is declared + `const trait`, at seven sites (`num.rs`, `align.rs`, `axis.rs`, + `pos.rs`, `color.rs`, `math.rs`, `vec2.rs`), and the unresolved + `UiVec2`/`Vec2`/`impl_op` imports cascade from those. That is the + nightly-drift risk in one build; the fix is mechanical (declare + the traits `const trait`), and it is the first item of I0b rather + than pinning back to a January nightly, which would only defer it. - [ ] **I1 — the text stack decision.** iris uses cosmic-text; the transcript needs rich inline spans (links, code chips, colour), selection across many widgets with the platform's handles on the diff --git a/iris/.gitignore b/iris/.gitignore new file mode 100644 index 0000000..3b1d403 --- /dev/null +++ b/iris/.gitignore @@ -0,0 +1,2 @@ +/target +perf.data* diff --git a/iris/Cargo.lock b/iris/Cargo.lock new file mode 100644 index 0000000..0796ff1 --- /dev/null +++ b/iris/Cargo.lock @@ -0,0 +1,3635 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ab_glyph" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aligned" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685" +dependencies = [ + "as-slice", +] + +[[package]] +name = "aligned-vec" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b" +dependencies = [ + "equator", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "android-activity" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046" +dependencies = [ + "android-properties", + "bitflags 2.10.0", + "cc", + "cesu8", + "jni", + "jni-sys", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum", + "thiserror 1.0.69", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" + +[[package]] +name = "arbitrary" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1" + +[[package]] +name = "arboard" +version = "3.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf" +dependencies = [ + "clipboard-win", + "image", + "log", + "objc2 0.6.3", + "objc2-app-kit 0.3.2", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "parking_lot", + "percent-encoding", + "windows-sys 0.60.2", + "wl-clipboard-rs", + "x11rb", +] + +[[package]] +name = "arg_enum_proc_macro" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "as-raw-xcb-connection" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" + +[[package]] +name = "as-slice" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516" +dependencies = [ + "stable_deref_trait", +] + +[[package]] +name = "ash" +version = "0.38.0+1.3.281" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" +dependencies = [ + "libloading", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "av-scenechange" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394" +dependencies = [ + "aligned", + "anyhow", + "arg_enum_proc_macro", + "arrayvec", + "log", + "num-rational", + "num-traits", + "pastey", + "rayon", + "thiserror 2.0.17", + "v_frame", + "y4m", +] + +[[package]] +name = "av1-grain" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8" +dependencies = [ + "anyhow", + "arrayvec", + "log", + "nom", + "num-rational", + "v_frame", +] + +[[package]] +name = "avif-serialize" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47c8fbc0f831f4519fe8b810b6a7a91410ec83031b8233f730a0480029f6a23f" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bit_field" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" + +[[package]] +name = "bitstream-io" +version = "4.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60d4bd9d1db2c6bdf285e223a7fa369d5ce98ec767dec949c6ca62863ce61757" +dependencies = [ + "core2", +] + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "block2" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" +dependencies = [ + "objc2 0.5.2", +] + +[[package]] +name = "built" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4ad8f11f288f48ca24471bbd51ac257aaeaaa07adae295591266b792902ae64" + +[[package]] +name = "bumpalo" +version = "3.19.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" + +[[package]] +name = "bytemuck" +version = "1.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "byteorder-lite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" + +[[package]] +name = "bytes" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3" + +[[package]] +name = "calloop" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" +dependencies = [ + "bitflags 2.10.0", + "log", + "polling", + "rustix 0.38.44", + "slab", + "thiserror 1.0.69", +] + +[[package]] +name = "calloop-wayland-source" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20" +dependencies = [ + "calloop", + "rustix 0.38.44", + "wayland-backend", + "wayland-client", +] + +[[package]] +name = "cc" +version = "1.2.51" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "clipboard-win" +version = "5.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4" +dependencies = [ + "error-code", +] + +[[package]] +name = "codespan-reporting" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81" +dependencies = [ + "serde", + "termcolor", + "unicode-width", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "combine" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "core-graphics-types 0.1.3", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation 0.9.4", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb" +dependencies = [ + "bitflags 2.10.0", + "core-foundation 0.10.1", + "libc", +] + +[[package]] +name = "core2" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505" +dependencies = [ + "memchr", +] + +[[package]] +name = "core_maths" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30" +dependencies = [ + "libm", +] + +[[package]] +name = "cosmic-text" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4cadaea21e24c49c0c82116f2b465ae6a49d63c90e428b0f8d9ae1f638ac91f" +dependencies = [ + "bitflags 2.10.0", + "fontdb", + "harfrust", + "linebender_resource_handle", + "log", + "rangemap", + "rustc-hash", + "self_cell", + "skrifa 0.39.0", + "smol_str", + "swash", + "sys-locale", + "unicode-bidi", + "unicode-linebreak", + "unicode-script", + "unicode-segmentation", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "cursor-icon" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dispatch2" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec" +dependencies = [ + "bitflags 2.10.0", + "objc2 0.6.3", +] + +[[package]] +name = "dlib" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412" +dependencies = [ + "libloading", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "downcast-rs" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" + +[[package]] +name = "dpi" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "equator" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc" +dependencies = [ + "equator-macro", +] + +[[package]] +name = "equator-macro" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "error-code" +version = "3.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59" + +[[package]] +name = "exr" +version = "1.74.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4300e043a56aa2cb633c01af81ca8f699a321879a7854d3896a0ba89056363be" +dependencies = [ + "bit_field", + "half", + "lebe", + "miniz_oxide", + "rayon-core", + "smallvec", + "zune-inflate", +] + +[[package]] +name = "fax" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f05de7d48f37cd6730705cbca900770cab77a89f413d23e100ad7fad7795a0ab" +dependencies = [ + "fax_derive", +] + +[[package]] +name = "fax_derive" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "fdeflate" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff" + +[[package]] +name = "fixedbitset" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" + +[[package]] +name = "flate2" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "font-types" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39a654f404bbcbd48ea58c617c2993ee91d1cb63727a37bf2323a4edeed1b8c5" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "fontconfig-parser" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646" +dependencies = [ + "roxmltree", +] + +[[package]] +name = "fontdb" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905" +dependencies = [ + "fontconfig-parser", + "log", + "memmap2", + "slotmap", + "tinyvec", + "ttf-parser", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "fxhash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" +dependencies = [ + "byteorder", +] + +[[package]] +name = "gethostname" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" +dependencies = [ + "rustix 1.1.3", + "windows-link", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + +[[package]] +name = "gif" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5df2ba84018d80c213569363bdcd0c64e6933c67fe4c1d60ecf822971a3c35e" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "gl_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d" +dependencies = [ + "khronos_api", + "log", + "xml-rs", +] + +[[package]] +name = "glow" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5e5ea60d70410161c8bf5da3fdfeaa1c72ed2c15f8bbb9d19fe3a4fad085f08" +dependencies = [ + "js-sys", + "slotmap", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "glutin_wgl_sys" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e" +dependencies = [ + "gl_generator", +] + +[[package]] +name = "gpu-allocator" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795" +dependencies = [ + "ash", + "hashbrown 0.16.1", + "log", + "presser", + "thiserror 2.0.17", + "windows", +] + +[[package]] +name = "gpu-descriptor" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca" +dependencies = [ + "bitflags 2.10.0", + "gpu-descriptor-types", + "hashbrown 0.15.5", +] + +[[package]] +name = "gpu-descriptor-types" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + +[[package]] +name = "harfrust" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0caaee032384c10dd597af4579c67dee16650d862a9ccbe1233ff1a379abc07" +dependencies = [ + "bitflags 2.10.0", + "bytemuck", + "core_maths", + "read-fonts 0.36.0", + "smallvec", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "hermit-abi" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" + +[[package]] +name = "hexf-parse" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" + +[[package]] +name = "image" +version = "0.25.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" +dependencies = [ + "bytemuck", + "byteorder-lite", + "color_quant", + "exr", + "gif", + "image-webp", + "moxcms", + "num-traits", + "png", + "qoi", + "ravif", + "rayon", + "rgb", + "tiff", + "zune-core 0.5.0", + "zune-jpeg 0.5.8", +] + +[[package]] +name = "image-webp" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3" +dependencies = [ + "byteorder-lite", + "quick-error", +] + +[[package]] +name = "imgref" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c5cedc30da3a610cac6b4ba17597bdf7152cf974e8aab3afb3d54455e371c8" + +[[package]] +name = "indexmap" +version = "2.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", +] + +[[package]] +name = "interpolate_name" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "iris" +version = "0.1.0" +dependencies = [ + "arboard", + "cosmic-text", + "image", + "iris-core", + "iris-macro", + "pollster", + "tokio", + "unicode-segmentation", + "wgpu", + "winit", +] + +[[package]] +name = "iris-core" +version = "0.1.0" +dependencies = [ + "bytemuck", + "cosmic-text", + "fxhash", + "image", + "wgpu", + "winit", +] + +[[package]] +name = "iris-macro" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "jni" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +dependencies = [ + "cesu8", + "cfg-if", + "combine", + "jni-sys", + "log", + "thiserror 1.0.69", + "walkdir", + "windows-sys 0.45.0", +] + +[[package]] +name = "jni-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "khronos-egl" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76" +dependencies = [ + "libc", + "libloading", + "pkg-config", +] + +[[package]] +name = "khronos_api" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" + +[[package]] +name = "lebe" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8" + +[[package]] +name = "libc" +version = "0.2.179" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5a2d376baa530d1238d133232d15e239abad80d05838b4b59354e5268af431f" + +[[package]] +name = "libfuzzer-sys" +version = "0.4.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5037190e1f70cbeef565bd267599242926f724d3b8a9f510fd7e0b540cfa4404" +dependencies = [ + "arbitrary", + "cc", +] + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" + +[[package]] +name = "libredox" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616" +dependencies = [ + "bitflags 2.10.0", + "libc", + "redox_syscall 0.7.0", +] + +[[package]] +name = "linebender_resource_handle" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4" + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "loop9" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062" +dependencies = [ + "imgref", +] + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "maybe-rayon" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519" +dependencies = [ + "cfg-if", + "rayon", +] + +[[package]] +name = "memchr" +version = "2.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" + +[[package]] +name = "memmap2" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490" +dependencies = [ + "libc", +] + +[[package]] +name = "metal" +version = "0.33.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7047791b5bc903b8cd963014b355f71dc9864a9a0b727057676c1dcae5cbc15" +dependencies = [ + "bitflags 2.10.0", + "block", + "core-graphics-types 0.2.0", + "foreign-types", + "log", + "objc", + "paste", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "moxcms" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97" +dependencies = [ + "num-traits", + "pxfm", +] + +[[package]] +name = "naga" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "618f667225063219ddfc61251087db8a9aec3c3f0950c916b614e403486f1135" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags 2.10.0", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown 0.16.1", + "hexf-parse", + "indexmap", + "libm", + "log", + "num-traits", + "once_cell", + "rustc-hash", + "spirv", + "thiserror 2.0.17", + "unicode-ident", +] + +[[package]] +name = "ndk" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" +dependencies = [ + "bitflags 2.10.0", + "jni-sys", + "log", + "ndk-sys", + "num_enum", + "raw-window-handle", + "thiserror 1.0.69", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys", +] + +[[package]] +name = "new_debug_unreachable" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" + +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + +[[package]] +name = "noop_proc_macro" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8" + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "num_enum" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "objc-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" + +[[package]] +name = "objc2" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804" +dependencies = [ + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c2599ce0ec54857b29ce62166b0ed9b4f6f1a70ccc9a71165b6154caca8c05" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-app-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" +dependencies = [ + "bitflags 2.10.0", + "block2", + "libc", + "objc2 0.5.2", + "objc2-core-data", + "objc2-core-image", + "objc2-foundation 0.2.2", + "objc2-quartz-core", +] + +[[package]] +name = "objc2-app-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c" +dependencies = [ + "bitflags 2.10.0", + "objc2 0.6.3", + "objc2-core-graphics", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-contacts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" +dependencies = [ + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-data" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.10.0", + "dispatch2", + "objc2 0.6.3", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags 2.10.0", + "dispatch2", + "objc2 0.6.3", + "objc2-core-foundation", + "objc2-io-surface", +] + +[[package]] +name = "objc2-core-image" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" +dependencies = [ + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal", +] + +[[package]] +name = "objc2-core-location" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" +dependencies = [ + "block2", + "objc2 0.5.2", + "objc2-contacts", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" +dependencies = [ + "bitflags 2.10.0", + "block2", + "dispatch", + "libc", + "objc2 0.5.2", +] + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.10.0", + "objc2 0.6.3", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-surface" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" +dependencies = [ + "bitflags 2.10.0", + "objc2 0.6.3", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-link-presentation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" +dependencies = [ + "block2", + "objc2 0.5.2", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal", +] + +[[package]] +name = "objc2-symbols" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" +dependencies = [ + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-image", + "objc2-core-location", + "objc2-foundation 0.2.2", + "objc2-link-presentation", + "objc2-quartz-core", + "objc2-symbols", + "objc2-uniform-type-identifiers", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-uniform-type-identifiers" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" +dependencies = [ + "block2", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" +dependencies = [ + "bitflags 2.10.0", + "block2", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "orbclient" +version = "0.3.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ad2c6bae700b7aa5d1cc30c59bdd3a1c180b09dbaea51e2ae2b8e1cf211fdd" +dependencies = [ + "libc", + "libredox", +] + +[[package]] +name = "ordered-float" +version = "5.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d" +dependencies = [ + "num-traits", +] + +[[package]] +name = "os_pipe" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "owned_ttf_parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pastey" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec" + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "petgraph" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455" +dependencies = [ + "fixedbitset", + "hashbrown 0.15.5", + "indexmap", +] + +[[package]] +name = "pin-project" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "png" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0" +dependencies = [ + "bitflags 2.10.0", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.3", + "windows-sys 0.61.2", +] + +[[package]] +name = "pollster" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" + +[[package]] +name = "portable-atomic" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" + +[[package]] +name = "portable-atomic-util" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "presser" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" + +[[package]] +name = "proc-macro-crate" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773" +dependencies = [ + "profiling-procmacros", +] + +[[package]] +name = "profiling-procmacros" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "pxfm" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8" +dependencies = [ + "num-traits", +] + +[[package]] +name = "qoi" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "quick-error" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3" + +[[package]] +name = "quick-xml" +version = "0.38.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +dependencies = [ + "getrandom", +] + +[[package]] +name = "range-alloc" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde" + +[[package]] +name = "rangemap" +version = "1.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "973443cf09a9c8656b574a866ab68dfa19f0867d0340648c7d2f6a71b8a8ea68" + +[[package]] +name = "rav1e" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b" +dependencies = [ + "aligned-vec", + "arbitrary", + "arg_enum_proc_macro", + "arrayvec", + "av-scenechange", + "av1-grain", + "bitstream-io", + "built", + "cfg-if", + "interpolate_name", + "itertools", + "libc", + "libfuzzer-sys", + "log", + "maybe-rayon", + "new_debug_unreachable", + "noop_proc_macro", + "num-derive", + "num-traits", + "paste", + "profiling", + "rand", + "rand_chacha", + "simd_helpers", + "thiserror 2.0.17", + "v_frame", + "wasm-bindgen", +] + +[[package]] +name = "ravif" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef69c1990ceef18a116855938e74793a5f7496ee907562bd0857b6ac734ab285" +dependencies = [ + "avif-serialize", + "imgref", + "loop9", + "quick-error", + "rav1e", + "rayon", + "rgb", +] + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "rayon" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "read-fonts" +version = "0.35.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358" +dependencies = [ + "bytemuck", + "font-types", +] + +[[package]] +name = "read-fonts" +version = "0.36.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eaa2941a4c05443ee3a7b26ab076a553c343ad5995230cc2b1d3e993bdc6345" +dependencies = [ + "bytemuck", + "core_maths", + "font-types", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "redox_syscall" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49f3fe0889e69e2ae9e41f4d6c4c0181701d00e4697b356fb1f74173a5e0ee27" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "renderdoc-sys" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" + +[[package]] +name = "rgb" +version = "0.8.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce" + +[[package]] +name = "roxmltree" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags 2.10.0", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags 2.10.0", + "errno", + "libc", + "linux-raw-sys 0.11.0", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "sctk-adwaita" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" +dependencies = [ + "ab_glyph", + "log", + "memmap2", + "smithay-client-toolkit", + "tiny-skia", +] + +[[package]] +name = "self_cell" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "simd-adler32" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" + +[[package]] +name = "simd_helpers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6" +dependencies = [ + "quote", +] + +[[package]] +name = "skrifa" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c31071dedf532758ecf3fed987cdb4bd9509f900e026ab684b4ecb81ea49841" +dependencies = [ + "bytemuck", + "read-fonts 0.35.0", +] + +[[package]] +name = "skrifa" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9eb0b904a04d09bd68c65d946617b8ff733009999050f3b851c32fb3cfb60e" +dependencies = [ + "bytemuck", + "read-fonts 0.36.0", +] + +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "smithay-client-toolkit" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" +dependencies = [ + "bitflags 2.10.0", + "calloop", + "calloop-wayland-source", + "cursor-icon", + "libc", + "log", + "memmap2", + "rustix 0.38.44", + "thiserror 1.0.69", + "wayland-backend", + "wayland-client", + "wayland-csd-frame", + "wayland-cursor", + "wayland-protocols", + "wayland-protocols-wlr", + "wayland-scanner", + "xkeysym", +] + +[[package]] +name = "smol_str" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" +dependencies = [ + "serde", +] + +[[package]] +name = "spirv" +version = "0.3.0+sdk-1.3.268.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "strict-num" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" + +[[package]] +name = "swash" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47846491253e976bdd07d0f9cc24b7daf24720d11309302ccbbc6e6b6e53550a" +dependencies = [ + "skrifa 0.37.0", + "yazi", + "zeno", +] + +[[package]] +name = "syn" +version = "2.0.113" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "678faa00651c9eb72dd2020cbdf275d92eccb2400d568e419efdd64838145cb4" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sys-locale" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4" +dependencies = [ + "libc", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +dependencies = [ + "thiserror-impl 2.0.17", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tiff" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af9605de7fee8d9551863fd692cce7637f548dbd9db9180fcc07ccc6d26c336f" +dependencies = [ + "fax", + "flate2", + "half", + "quick-error", + "weezl", + "zune-jpeg 0.4.21", +] + +[[package]] +name = "tiny-skia" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" +dependencies = [ + "arrayref", + "arrayvec", + "bytemuck", + "cfg-if", + "log", + "tiny-skia-path", +] + +[[package]] +name = "tiny-skia-path" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" +dependencies = [ + "arrayref", + "bytemuck", + "strict-num", +] + +[[package]] +name = "tinyvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.49.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +dependencies = [ + "pin-project-lite", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.23.10+spec-1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.0.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44" +dependencies = [ + "winnow", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" + +[[package]] +name = "tree_magic_mini" +version = "3.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6" +dependencies = [ + "memchr", + "nom", + "petgraph", +] + +[[package]] +name = "ttf-parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" +dependencies = [ + "core_maths", +] + +[[package]] +name = "unicode-bidi" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" + +[[package]] +name = "unicode-ident" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" + +[[package]] +name = "unicode-linebreak" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f" + +[[package]] +name = "unicode-script" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee" + +[[package]] +name = "unicode-segmentation" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "v_frame" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2" +dependencies = [ + "aligned-vec", + "num-traits", + "wasm-bindgen", +] + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c" +dependencies = [ + "cfg-if", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wayland-backend" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fee64194ccd96bf648f42a65a7e589547096dfa702f7cadef84347b66ad164f9" +dependencies = [ + "cc", + "downcast-rs", + "rustix 1.1.3", + "scoped-tls", + "smallvec", + "wayland-sys", +] + +[[package]] +name = "wayland-client" +version = "0.31.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e6faa537fbb6c186cb9f1d41f2f811a4120d1b57ec61f50da451a0c5122bec" +dependencies = [ + "bitflags 2.10.0", + "rustix 1.1.3", + "wayland-backend", + "wayland-scanner", +] + +[[package]] +name = "wayland-csd-frame" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" +dependencies = [ + "bitflags 2.10.0", + "cursor-icon", + "wayland-backend", +] + +[[package]] +name = "wayland-cursor" +version = "0.31.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5864c4b5b6064b06b1e8b74ead4a98a6c45a285fe7a0e784d24735f011fdb078" +dependencies = [ + "rustix 1.1.3", + "wayland-client", + "xcursor", +] + +[[package]] +name = "wayland-protocols" +version = "0.32.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baeda9ffbcfc8cd6ddaade385eaf2393bd2115a69523c735f12242353c3df4f3" +dependencies = [ + "bitflags 2.10.0", + "wayland-backend", + "wayland-client", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-plasma" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa98634619300a535a9a97f338aed9a5ff1e01a461943e8346ff4ae26007306b" +dependencies = [ + "bitflags 2.10.0", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-wlr" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9597cdf02cf0c34cd5823786dce6b5ae8598f05c2daf5621b6e178d4f7345f3" +dependencies = [ + "bitflags 2.10.0", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-scanner" +version = "0.31.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5423e94b6a63e68e439803a3e153a9252d5ead12fd853334e2ad33997e3889e3" +dependencies = [ + "proc-macro2", + "quick-xml", + "quote", +] + +[[package]] +name = "wayland-sys" +version = "0.31.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e6dbfc3ac5ef974c92a2235805cc0114033018ae1290a72e474aa8b28cbbdfd" +dependencies = [ + "dlib", + "log", + "once_cell", + "pkg-config", +] + +[[package]] +name = "web-sys" +version = "0.3.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "weezl" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" + +[[package]] +name = "wgpu" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9cb534d5ffd109c7d1135f34cdae29e60eab94855a625dcfe1705f8bc7ad79f" +dependencies = [ + "arrayvec", + "bitflags 2.10.0", + "bytemuck", + "cfg-if", + "cfg_aliases", + "document-features", + "hashbrown 0.16.1", + "js-sys", + "log", + "naga", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bb4c8b5db5f00e56f1f08869d870a0dff7c8bc7ebc01091fec140b0cf0211a9" +dependencies = [ + "arrayvec", + "bit-set", + "bit-vec", + "bitflags 2.10.0", + "bytemuck", + "cfg_aliases", + "document-features", + "hashbrown 0.16.1", + "indexmap", + "log", + "naga", + "once_cell", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "rustc-hash", + "smallvec", + "thiserror 2.0.17", + "wgpu-core-deps-apple", + "wgpu-core-deps-emscripten", + "wgpu-core-deps-windows-linux-android", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core-deps-apple" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87b7b696b918f337c486bf93142454080a32a37832ba8a31e4f48221890047da" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-emscripten" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34b251c331f84feac147de3c4aa3aa45112622a95dd7ee1b74384fa0458dbd79" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-windows-linux-android" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ca976e72b2c9964eb243e281f6ce7f14a514e409920920dcda12ae40febaae" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-hal" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "293080d77fdd14d6b08a67c5487dfddbf874534bb7921526db56a7b75d7e3bef" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bit-set", + "bitflags 2.10.0", + "block", + "bytemuck", + "cfg-if", + "cfg_aliases", + "core-graphics-types 0.2.0", + "glow", + "glutin_wgl_sys", + "gpu-allocator", + "gpu-descriptor", + "hashbrown 0.16.1", + "js-sys", + "khronos-egl", + "libc", + "libloading", + "log", + "metal", + "naga", + "ndk-sys", + "objc", + "once_cell", + "ordered-float", + "parking_lot", + "portable-atomic", + "portable-atomic-util", + "profiling", + "range-alloc", + "raw-window-handle", + "renderdoc-sys", + "smallvec", + "thiserror 2.0.17", + "wasm-bindgen", + "web-sys", + "wgpu-types", + "windows", + "windows-core", +] + +[[package]] +name = "wgpu-types" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e18308757e594ed2cd27dddbb16a139c42a683819d32a2e0b1b0167552f5840c" +dependencies = [ + "bitflags 2.10.0", + "bytemuck", + "js-sys", + "log", + "web-sys", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winit" +version = "0.30.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c66d4b9ed69c4009f6321f762d6e61ad8a2389cd431b97cb1e146812e9e6c732" +dependencies = [ + "ahash", + "android-activity", + "atomic-waker", + "bitflags 2.10.0", + "block2", + "bytemuck", + "calloop", + "cfg_aliases", + "concurrent-queue", + "core-foundation 0.9.4", + "core-graphics", + "cursor-icon", + "dpi", + "js-sys", + "libc", + "memmap2", + "ndk", + "objc2 0.5.2", + "objc2-app-kit 0.2.2", + "objc2-foundation 0.2.2", + "objc2-ui-kit", + "orbclient", + "percent-encoding", + "pin-project", + "raw-window-handle", + "redox_syscall 0.4.1", + "rustix 0.38.44", + "sctk-adwaita", + "smithay-client-toolkit", + "smol_str", + "tracing", + "unicode-segmentation", + "wasm-bindgen", + "wasm-bindgen-futures", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-plasma", + "web-sys", + "web-time", + "windows-sys 0.52.0", + "x11-dl", + "x11rb", + "xkbcommon-dl", +] + +[[package]] +name = "winnow" +version = "0.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" + +[[package]] +name = "wl-clipboard-rs" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3" +dependencies = [ + "libc", + "log", + "os_pipe", + "rustix 1.1.3", + "thiserror 2.0.17", + "tree_magic_mini", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-wlr", +] + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" +dependencies = [ + "as-raw-xcb-connection", + "gethostname", + "libc", + "libloading", + "once_cell", + "rustix 1.1.3", + "x11rb-protocol", +] + +[[package]] +name = "x11rb-protocol" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" + +[[package]] +name = "xcursor" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b" + +[[package]] +name = "xkbcommon-dl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" +dependencies = [ + "bitflags 2.10.0", + "dlib", + "log", + "once_cell", + "xkeysym", +] + +[[package]] +name = "xkeysym" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" + +[[package]] +name = "xml-rs" +version = "0.8.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f" + +[[package]] +name = "y4m" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448" + +[[package]] +name = "yazi" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" + +[[package]] +name = "zeno" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6df3dc4292935e51816d896edcd52aa30bc297907c26167fec31e2b0c6a32524" + +[[package]] +name = "zerocopy" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zune-core" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a" + +[[package]] +name = "zune-core" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "111f7d9820f05fd715df3144e254d6fc02ee4088b0644c0ffd0efc9e6d9d2773" + +[[package]] +name = "zune-inflate" +version = "0.2.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "zune-jpeg" +version = "0.4.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713" +dependencies = [ + "zune-core 0.4.12", +] + +[[package]] +name = "zune-jpeg" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e35aee689668bf9bd6f6f3a6c60bb29ba1244b3b43adfd50edd554a371da37d5" +dependencies = [ + "zune-core 0.5.0", +] diff --git a/iris/Cargo.toml b/iris/Cargo.toml new file mode 100644 index 0000000..9c2276a --- /dev/null +++ b/iris/Cargo.toml @@ -0,0 +1,42 @@ +[package] +name = "iris" +version.workspace = true +edition.workspace = true + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +iris-core = { workspace = true } +iris-macro = { workspace = true } +cosmic-text = { workspace = true } +unicode-segmentation = { workspace = true } +winit = { workspace = true } +arboard = { workspace = true, features = ["wayland-data-control"] } +pollster = { workspace = true } +wgpu = { workspace = true } +image = { workspace = true } +tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] } + +[dev-dependencies] +tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] } + +[workspace] +members = ["core", "macro"] + +[workspace.package] +version = "0.1.0" +edition = "2024" + +[workspace.dependencies] +pollster = "0.4.0" +winit = "0.30.12" +wgpu = "28.0.0" +bytemuck = "1.23.1" +image = "0.25.6" +cosmic-text = "0.16.0" +unicode-segmentation = "1.12.0" +fxhash = "0.2.1" +arboard = "3.6.1" +iris-core = { path = "core" } +iris-macro = { path = "macro" } +tokio = "1.49.0" diff --git a/iris/TODO b/iris/TODO new file mode 100644 index 0000000..c4f9356 --- /dev/null +++ b/iris/TODO @@ -0,0 +1,40 @@ +images + settings (sampler) + +text + figure out ways to speed up / what costs the most + resizing (per frame) is really slow (assuming painter isn't griefing) + j is weird / fix x offset + +masks r just made to bare minimum work + +scaling + could be just a simple scaling factor that multiplies abs + and need to ensure text uses raw abs and not scaled abs + naming? (pt, px) + want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec + field could be best solution so redrawing stuff isn't needed & you can specify both as user + +WidgetRef or smth instead of Id + enum that's either an Id or an actual concrete instance of W + painter takes them in instead of (or in addition to) id + then type wrapper widgets to contain them + allows for compile time optimization if a widget wrapper's inner is known at compile time + and the id of inner is not needed anywhere + maybe introduce InnerWidget trait to allow for editors to expose & modify inner type + maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible + +really weird limitation: + I don't think you can currently remove an element from a parent and put it in a child of the same parent + because it removes the unused children after the entire parent redraw + but the child gets drawn during that, so it will think the child is still active !!! + or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent + or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way) + ok so I'm removing the limit for now + +don't forget I'm streaming + +tags +vecs for each widget type? + +POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..?? diff --git a/iris/core/Cargo.toml b/iris/core/Cargo.toml new file mode 100644 index 0000000..a85a26d --- /dev/null +++ b/iris/core/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "iris-core" +version.workspace = true +edition.workspace = true + +[dependencies] +winit = { workspace = true } +wgpu = { workspace = true } +bytemuck ={ workspace = true } +image = { workspace = true } +cosmic-text = { workspace = true } +fxhash = { workspace = true } diff --git a/iris/core/src/attr.rs b/iris/core/src/attr.rs new file mode 100644 index 0000000..6d0a28e --- /dev/null +++ b/iris/core/src/attr.rs @@ -0,0 +1,23 @@ +use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget}; + +pub trait WidgetAttr { + type Input; + fn run(rsc: &mut Rsc, id: WeakWidget, input: Self::Input); +} + +pub trait Attrable { + fn attr>(self, input: A::Input) -> impl WidgetIdFn; +} + +impl, Tag> Attrable for WL { + fn attr>( + self, + input: A::Input, + ) -> impl WidgetIdFn { + |rsc| { + let id = self.add(rsc); + A::run(rsc, id, input); + id + } + } +} diff --git a/iris/core/src/event/ctx.rs b/iris/core/src/event/ctx.rs new file mode 100644 index 0000000..f5894a9 --- /dev/null +++ b/iris/core/src/event/ctx.rs @@ -0,0 +1,18 @@ +use crate::{HasEvents, WeakWidget, Widget}; + +pub struct EventCtx<'a, Rsc: HasEvents, Data> { + pub state: &'a mut Rsc::State, + pub data: Data, +} + +pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> { + pub widget: WeakWidget, + pub state: &'a mut Rsc::State, + pub data: Data, +} + +impl EventIdCtx<'_, Rsc, Data, W> { + pub fn widget<'a>(&self, rsc: &'a mut Rsc) -> &'a mut W { + &mut rsc.ui_mut().widgets[self.widget] + } +} diff --git a/iris/core/src/event/manager.rs b/iris/core/src/event/manager.rs new file mode 100644 index 0000000..840fcb8 --- /dev/null +++ b/iris/core/src/event/manager.rs @@ -0,0 +1,157 @@ +use crate::{ + ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId, + WeakWidget, WidgetEventFn, WidgetId, + util::{HashMap, HashSet, TypeMap}, +}; +use std::{any::TypeId, rc::Rc}; + +pub struct EventManager { + widget_to_types: HashMap>, + types: TypeMap>, +} + +impl Default for EventManager { + fn default() -> Self { + Self { + widget_to_types: Default::default(), + types: Default::default(), + } + } +} + +impl EventManager { + pub fn get_type(&mut self) -> &mut TypeEventManager { + self.types.type_or_default() + } + + pub fn register( + &mut self, + id: I, + event: E, + f: impl for<'a> WidgetEventFn::Data<'a>, I::Widget>, + ) { + let i = id.id(); + self.get_type::().register(id, event, f); + self.widget_to_types + .entry(i) + .or_default() + .insert(Self::type_key::()); + } + + pub fn type_key() -> TypeId { + TypeId::of::>() + } +} + +pub trait EventsLike { + fn remove(&mut self, id: WidgetId); + fn draw(&mut self, active: &ActiveData); + fn undraw(&mut self, active: &ActiveData); +} + +impl EventsLike for EventManager { + fn remove(&mut self, id: WidgetId) { + for t in self.widget_to_types.get(&id).into_flat_iter() { + self.types.get_mut(t).unwrap().remove(id); + } + } + + fn draw(&mut self, active: &ActiveData) { + for t in self.widget_to_types.get(&active.id).into_flat_iter() { + self.types.get_mut(t).unwrap().draw(active); + } + } + + fn undraw(&mut self, active: &ActiveData) { + for t in self.widget_to_types.get(&active.id).into_flat_iter() { + self.types.get_mut(t).unwrap().undraw(active); + } + } +} + +pub trait EventManagerLike { + fn remove(&mut self, id: WidgetId); + fn draw(&mut self, data: &ActiveData); + fn undraw(&mut self, data: &ActiveData); +} + +type EventData = (E, Rc EventFn::Data<'a>>>); +pub struct TypeEventManager { + // TODO: reduce visiblity!! + pub active: HashMap>, + map: HashMap>>, +} + +impl EventManagerLike for TypeEventManager { + fn remove(&mut self, id: WidgetId) { + self.map.remove(&id); + for layer in self.active.values_mut() { + layer.remove(&id); + } + } + fn draw(&mut self, data: &ActiveData) { + self.active + .entry(data.layer) + .or_default() + .entry(data.id) + .or_default(); + } + fn undraw(&mut self, data: &ActiveData) { + if let Some(layer) = self.active.get_mut(&data.layer) { + layer.remove(&data.id); + } + } +} + +impl Default for TypeEventManager { + fn default() -> Self { + Self { + active: Default::default(), + map: Default::default(), + } + } +} + +impl TypeEventManager { + fn register( + &mut self, + widget: I, + event: impl EventLike, + f: impl for<'a> WidgetEventFn, I::Widget>, + ) { + let event = event.into_event(); + self.map.entry(widget.id()).or_default().push(( + event, + Rc::new(move |ctx, rsc| { + f( + EventIdCtx { + widget: WeakWidget::new(widget.id()), + state: ctx.state, + data: ctx.data, + }, + rsc, + ); + }), + )); + } + + pub fn run_fn<'a>( + &mut self, + id: impl IdLike, + ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a { + let fs = self.map.get(&id.id()).cloned().unwrap_or_default(); + move |ctx, rsc| { + for (e, f) in fs { + if let Some(data) = e.should_run(&ctx.data) { + f( + EventCtx { + state: ctx.state, + data, + }, + rsc, + ) + } + } + } + } +} diff --git a/iris/core/src/event/mod.rs b/iris/core/src/event/mod.rs new file mode 100644 index 0000000..7b038f4 --- /dev/null +++ b/iris/core/src/event/mod.rs @@ -0,0 +1,44 @@ +mod ctx; +mod manager; +mod rsc; + +pub use ctx::*; +pub use manager::*; +pub use rsc::*; + +pub trait Event: Sized + 'static + Clone { + type Data<'a>: Clone = (); + type State: Default = (); + #[allow(unused_variables)] + fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option> { + Some(data.clone()) + } +} + +pub trait EventLike { + type Event: Event; + fn into_event(self) -> Self::Event; +} + +impl EventLike for E { + type Event = Self; + + fn into_event(self) -> Self::Event { + self + } +} + +pub trait EventFn: Fn(EventCtx, &mut Rsc) + 'static {} +impl, &mut Rsc) + 'static, Data> EventFn + for F +{ +} + +pub trait WidgetEventFn: + Fn(EventIdCtx, &mut Rsc) + 'static +{ +} +impl, &mut Rsc) + 'static, Data, W: ?Sized> + WidgetEventFn for F +{ +} diff --git a/iris/core/src/event/rsc.rs b/iris/core/src/event/rsc.rs new file mode 100644 index 0000000..4824a99 --- /dev/null +++ b/iris/core/src/event/rsc.rs @@ -0,0 +1,34 @@ +use crate::{ + Event, EventCtx, EventLike, EventManager, IdLike, UiRsc, WeakWidget, Widget, WidgetEventFn, +}; + +pub trait HasState: 'static { + type State; +} + +pub trait HasEvents: Sized + UiRsc + HasState { + fn events(&self) -> &EventManager; + fn events_mut(&mut self) -> &mut EventManager; + + fn register_event( + &mut self, + id: WeakWidget, + event: E, + f: impl for<'a> WidgetEventFn::Data<'a>, W>, + ) { + self.events_mut().register(id, event, f); + } +} + +pub trait RunEvents: HasEvents { + fn run_event( + &mut self, + id: impl IdLike, + data: ::Data<'_>, + state: &mut Self::State, + ) { + let f = self.events_mut().get_type::().run_fn(id); + f(EventCtx { state, data }, self) + } +} +impl RunEvents for T {} diff --git a/iris/core/src/lib.rs b/iris/core/src/lib.rs new file mode 100644 index 0000000..f60415a --- /dev/null +++ b/iris/core/src/lib.rs @@ -0,0 +1,36 @@ +#![feature(macro_metavar_expr_concat)] +#![feature(const_ops)] +#![feature(const_trait_impl)] +#![feature(const_convert)] +#![feature(map_try_insert)] +#![feature(unboxed_closures)] +#![feature(fn_traits)] +#![feature(const_cmp)] +#![feature(const_destruct)] +#![feature(portable_simd)] +#![feature(associated_type_defaults)] +#![feature(unsize)] +#![feature(coerce_unsized)] +#![feature(option_into_flat_iter)] + +mod attr; +mod event; +mod num; +mod orientation; +mod primitive; +mod render; +mod ui; +mod widget; + +pub mod util; + +pub use attr::*; +pub use event::*; +pub use num::*; +pub use orientation::*; +pub use primitive::*; +pub use render::*; +pub use ui::*; +pub use widget::*; + +pub type UiColor = primitive::Color; diff --git a/iris/core/src/num.rs b/iris/core/src/num.rs new file mode 100644 index 0000000..c4ad5cd --- /dev/null +++ b/iris/core/src/num.rs @@ -0,0 +1,49 @@ +use crate::util::Vec2; +use std::marker::Destruct; + +pub const trait UiNum { + fn to_f32(self) -> f32; +} + +impl const UiNum for f32 { + fn to_f32(self) -> f32 { + self + } +} + +impl const UiNum for u32 { + fn to_f32(self) -> f32 { + self as f32 + } +} + +impl const UiNum for i32 { + fn to_f32(self) -> f32 { + self as f32 + } +} + +pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 { + Vec2::new(x.to_f32(), y.to_f32()) +} + +impl const From for Vec2 { + fn from(v: T) -> Self { + Self { + x: v.to_f32(), + y: v.to_f32(), + } + } +} + +impl const From<(T, U)> for Vec2 +where + (T, U): const Destruct, +{ + fn from((x, y): (T, U)) -> Self { + Self { + x: x.to_f32(), + y: y.to_f32(), + } + } +} diff --git a/iris/core/src/orientation/align.rs b/iris/core/src/orientation/align.rs new file mode 100644 index 0000000..4fe79d2 --- /dev/null +++ b/iris/core/src/orientation/align.rs @@ -0,0 +1,200 @@ +use crate::vec2; + +use super::*; + +#[derive(Clone, Copy, PartialEq, Eq)] +pub struct Align { + pub x: Option, + pub y: Option, +} + +impl Align { + pub const TOP_LEFT: RegionAlign = RegionAlign::TOP_LEFT; + pub const TOP_CENTER: RegionAlign = RegionAlign::TOP_CENTER; + pub const TOP_RIGHT: RegionAlign = RegionAlign::TOP_RIGHT; + pub const CENTER_LEFT: RegionAlign = RegionAlign::CENTER_LEFT; + pub const CENTER: RegionAlign = RegionAlign::CENTER; + pub const CENTER_RIGHT: RegionAlign = RegionAlign::CENTER_RIGHT; + pub const BOT_LEFT: RegionAlign = RegionAlign::BOT_LEFT; + pub const BOT_CENTER: RegionAlign = RegionAlign::BOT_CENTER; + pub const BOT_RIGHT: RegionAlign = RegionAlign::BOT_RIGHT; + pub const LEFT: CardinalAlign = CardinalAlign::LEFT; + pub const H_CENTER: CardinalAlign = CardinalAlign::H_CENTER; + pub const RIGHT: CardinalAlign = CardinalAlign::RIGHT; + pub const TOP: CardinalAlign = CardinalAlign::TOP; + pub const V_CENTER: CardinalAlign = CardinalAlign::V_CENTER; + pub const BOT: CardinalAlign = CardinalAlign::BOT; + + pub fn tuple(&self) -> (Option, Option) { + (self.x, self.y) + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum AxisAlign { + Neg, + Center, + Pos, +} + +impl AxisAlign { + pub const fn rel(&self) -> f32 { + match self { + Self::Neg => 0.0, + Self::Center => 0.5, + Self::Pos => 1.0, + } + } +} + +pub struct CardinalAlign { + axis: Axis, + align: AxisAlign, +} + +impl CardinalAlign { + pub const LEFT: Self = Self::new(Axis::X, AxisAlign::Neg); + pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::Center); + pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::Pos); + pub const TOP: Self = Self::new(Axis::Y, AxisAlign::Neg); + pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::Center); + pub const BOT: Self = Self::new(Axis::Y, AxisAlign::Pos); + + pub const fn new(axis: Axis, align: AxisAlign) -> Self { + Self { axis, align } + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +pub struct RegionAlign { + pub x: AxisAlign, + pub y: AxisAlign, +} + +impl RegionAlign { + pub const TOP_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Neg); + pub const TOP_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Neg); + pub const TOP_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Neg); + pub const CENTER_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Center); + pub const CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Center); + pub const CENTER_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Center); + pub const BOT_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Pos); + pub const BOT_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Pos); + pub const BOT_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Pos); + + pub const fn new(x: AxisAlign, y: AxisAlign) -> Self { + Self { x, y } + } + pub const fn rel(&self) -> Vec2 { + vec2(self.x.rel(), self.y.rel()) + } +} + +impl UiVec2 { + pub fn partial_align(&self, align: Align) -> UiRegion { + UiRegion { + x: if let Some(align) = align.x { + self.x.align(align) + } else { + UiSpan::FULL + }, + y: if let Some(align) = align.y { + self.y.align(align) + } else { + UiSpan::FULL + }, + } + } + + pub fn align(&self, align: RegionAlign) -> UiRegion { + UiRegion { + x: self.x.align(align.x), + y: self.y.align(align.y), + } + } +} + +impl Vec2 { + pub fn partial_align(&self, align: Align) -> UiRegion { + let s = UiVec2::from(*self); + UiRegion { + x: if let Some(align) = align.x { + s.x.align(align) + } else { + UiSpan::FULL + }, + y: if let Some(align) = align.y { + s.y.align(align) + } else { + UiSpan::FULL + }, + } + } + + pub fn align(&self, align: RegionAlign) -> UiRegion { + let s = UiVec2::from(*self); + UiRegion { + x: s.x.align(align.x), + y: s.y.align(align.y), + } + } +} + +impl UiScalar { + pub const fn align(&self, align: AxisAlign) -> UiSpan { + let rel = align.rel(); + let mut start = UiScalar::rel(rel); + start.abs -= self.abs * rel; + start.rel -= self.rel * rel; + let mut end = UiScalar::rel(rel); + end.abs += self.abs * (1.0 - rel); + end.rel += self.rel * (1.0 - rel); + UiSpan { start, end } + } +} + +impl From for Align { + fn from(region: RegionAlign) -> Self { + Self { + x: Some(region.x), + y: Some(region.y), + } + } +} + +impl From for RegionAlign { + fn from(align: Align) -> Self { + Self { + x: align.x.unwrap_or(AxisAlign::Center), + y: align.y.unwrap_or(AxisAlign::Center), + } + } +} + +impl From for RegionAlign { + fn from(align: CardinalAlign) -> Self { + Align::from(align).into() + } +} + +impl From for Align { + fn from(cardinal: CardinalAlign) -> Self { + let align = Some(cardinal.align); + match cardinal.axis { + Axis::X => Self { x: align, y: None }, + Axis::Y => Self { x: None, y: align }, + } + } +} + +impl const From for UiVec2 { + fn from(align: RegionAlign) -> Self { + Self::rel(align.rel()) + } +} + +impl RegionAlign { + pub const fn pos(self) -> UiVec2 { + UiVec2::from(self) + } +} diff --git a/iris/core/src/orientation/axis.rs b/iris/core/src/orientation/axis.rs new file mode 100644 index 0000000..0f31958 --- /dev/null +++ b/iris/core/src/orientation/axis.rs @@ -0,0 +1,115 @@ +use super::*; + +#[derive(Copy, Clone, Eq, PartialEq)] +pub enum Axis { + X, + Y, +} + +impl std::ops::Not for Axis { + type Output = Self; + + fn not(self) -> Self::Output { + match self { + Self::X => Self::Y, + Self::Y => Self::X, + } + } +} + +#[derive(Clone, Copy, Eq, PartialEq)] +pub struct Dir { + pub axis: Axis, + pub sign: Sign, +} + +impl Dir { + pub const fn new(axis: Axis, dir: Sign) -> Self { + Self { axis, sign: dir } + } + + pub const LEFT: Self = Self::new(Axis::X, Sign::Neg); + pub const RIGHT: Self = Self::new(Axis::X, Sign::Pos); + pub const UP: Self = Self::new(Axis::Y, Sign::Neg); + pub const DOWN: Self = Self::new(Axis::Y, Sign::Pos); +} + +#[derive(Clone, Copy, Eq, PartialEq)] +pub enum Sign { + Neg, + Pos, +} + +impl Vec2 { + pub fn axis(&self, axis: Axis) -> f32 { + match axis { + Axis::X => self.x, + Axis::Y => self.y, + } + } + + pub fn axis_mut(&mut self, axis: Axis) -> &mut f32 { + match axis { + Axis::X => &mut self.x, + Axis::Y => &mut self.y, + } + } + + pub const fn from_axis(axis: Axis, aligned: f32, ortho: f32) -> Self { + Self { + x: match axis { + Axis::X => aligned, + Axis::Y => ortho, + }, + y: match axis { + Axis::Y => aligned, + Axis::X => ortho, + }, + } + } +} + +pub const trait AxisT { + fn get() -> Axis; +} + +pub struct XAxis; +impl const AxisT for XAxis { + fn get() -> Axis { + Axis::X + } +} + +pub struct YAxis; +impl const AxisT for YAxis { + fn get() -> Axis { + Axis::Y + } +} + +#[derive(Clone, Copy, Debug, Default)] +pub struct BothAxis { + pub x: T, + pub y: T, +} + +impl BothAxis { + pub const fn axis(&mut self) -> &mut T { + match A::get() { + Axis::X => &mut self.x, + Axis::Y => &mut self.y, + } + } + pub fn take_axis(self) -> T { + match A::get() { + Axis::X => self.x, + Axis::Y => self.y, + } + } + pub fn axis_dyn(&mut self, axis: Axis) -> &mut T { + match axis { + Axis::X => &mut self.x, + Axis::Y => &mut self.y, + } + } +} diff --git a/iris/core/src/orientation/len.rs b/iris/core/src/orientation/len.rs new file mode 100644 index 0000000..8725211 --- /dev/null +++ b/iris/core/src/orientation/len.rs @@ -0,0 +1,198 @@ +use super::*; +use crate::{UiNum, util::impl_op}; + +#[derive(Debug, Default, Clone, Copy, PartialEq)] +pub struct Size { + pub x: Len, + pub y: Len, +} + +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Len { + pub abs: f32, + pub rel: f32, + pub rest: f32, +} + +impl From for Len { + fn from(value: N) -> Self { + Len::abs(value.to_f32()) + } +} + +impl From<(Nx, Ny)> for Size { + fn from((x, y): (Nx, Ny)) -> Self { + Self { + x: x.into(), + y: y.into(), + } + } +} + +impl From for Size { + fn from(value: Len) -> Self { + Self { x: value, y: value } + } +} + +impl Size { + pub const ZERO: Self = Self { + x: Len::ZERO, + y: Len::ZERO, + }; + + pub const REST: Self = Self { + x: Len::REST, + y: Len::REST, + }; + + pub fn abs(v: Vec2) -> Self { + Self { + x: Len::abs(v.x), + y: Len::abs(v.y), + } + } + + pub fn rel(v: Vec2) -> Self { + Self { + x: Len::rel(v.x), + y: Len::rel(v.y), + } + } + + pub fn rest(v: Vec2) -> Self { + Self { + x: Len::rest(v.x), + y: Len::rest(v.y), + } + } + + pub fn to_uivec2(self) -> UiVec2 { + UiVec2 { + x: self.x.apply_rest(), + y: self.y.apply_rest(), + } + } + + pub fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self { + match axis { + Axis::X => Self { + x: aligned, + y: ortho, + }, + Axis::Y => Self { + x: ortho, + y: aligned, + }, + } + } + + pub fn axis(&self, axis: Axis) -> Len { + match axis { + Axis::X => self.x, + Axis::Y => self.y, + } + } +} + +impl Len { + pub const ZERO: Self = Self { + abs: 0.0, + rel: 0.0, + rest: 0.0, + }; + + pub const REST: Self = Self { + abs: 0.0, + rel: 0.0, + rest: 1.0, + }; + + pub fn apply_rest(&self) -> UiScalar { + UiScalar { + rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 }, + abs: self.abs, + } + } + + pub fn abs(abs: impl UiNum) -> Self { + Self { + abs: abs.to_f32(), + rel: 0.0, + rest: 0.0, + } + } + pub fn rel(rel: impl UiNum) -> Self { + Self { + abs: 0.0, + rel: rel.to_f32(), + rest: 0.0, + } + } + pub fn rest(ratio: impl UiNum) -> Self { + Self { + abs: 0.0, + rel: 0.0, + rest: ratio.to_f32(), + } + } +} + +pub mod len_fns { + use super::*; + + pub fn abs(abs: impl UiNum) -> Len { + Len { + abs: abs.to_f32(), + rel: 0.0, + rest: 0.0, + } + } + pub fn rel(rel: impl UiNum) -> Len { + Len { + abs: 0.0, + rel: rel.to_f32(), + rest: 0.0, + } + } + pub fn rest(ratio: impl UiNum) -> Len { + Len { + abs: 0.0, + rel: 0.0, + rest: ratio.to_f32(), + } + } +} + +impl_op!(Len Add add; abs rel rest); +impl_op!(Len Sub sub; abs rel rest); + +impl_op!(Size Add add; x y); +impl_op!(Size Sub sub; x y); + +impl Default for Len { + fn default() -> Self { + Self::rest(1.0) + } +} + +impl std::fmt::Display for Size { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({}, {})", self.x, self.y) + } +} + +impl std::fmt::Display for Len { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + if self.abs != 0.0 { + write!(f, "{} abs;", self.abs)?; + } + if self.rel != 0.0 { + write!(f, "{} rel;", self.rel)?; + } + if self.rest != 0.0 { + write!(f, "{} rest;", self.rest)?; + } + Ok(()) + } +} diff --git a/iris/core/src/orientation/mod.rs b/iris/core/src/orientation/mod.rs new file mode 100644 index 0000000..65040ec --- /dev/null +++ b/iris/core/src/orientation/mod.rs @@ -0,0 +1,11 @@ +mod align; +mod axis; +mod len; +mod pos; + +use crate::util::Vec2; + +pub use align::*; +pub use axis::*; +pub use len::*; +pub use pos::*; diff --git a/iris/core/src/orientation/pos.rs b/iris/core/src/orientation/pos.rs new file mode 100644 index 0000000..204e048 --- /dev/null +++ b/iris/core/src/orientation/pos.rs @@ -0,0 +1,464 @@ +use std::{fmt::Display, hash::Hash, marker::Destruct}; + +use super::*; +use crate::{ + UiNum, + util::{LerpUtil, impl_op}, +}; + +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable, Default)] +pub struct UiVec2 { + pub x: UiScalar, + pub y: UiScalar, +} + +impl UiVec2 { + pub const ZERO: Self = Self { + x: UiScalar::ZERO, + y: UiScalar::ZERO, + }; + + pub const fn new(x: UiScalar, y: UiScalar) -> Self { + Self { x, y } + } + + pub const fn abs(abs: impl const Into) -> Self { + let abs = abs.into(); + Self { + x: UiScalar::abs(abs.x), + y: UiScalar::abs(abs.y), + } + } + + pub const fn rel(rel: impl const Into) -> Self { + let rel = rel.into(); + Self { + x: UiScalar::rel(rel.x), + y: UiScalar::rel(rel.y), + } + } + + pub const fn shift(&mut self, offset: impl const Into) { + let offset = offset.into(); + *self += offset; + } + + pub const fn offset(mut self, offset: impl const Into) -> Self { + self.shift(offset); + self + } + + pub const fn within(&self, region: &UiRegion) -> UiVec2 { + UiVec2 { + x: self.x.within(®ion.x), + y: self.y.within(®ion.y), + } + } + + pub const fn outside(&self, region: &UiRegion) -> UiVec2 { + UiVec2 { + x: self.x.outside(®ion.x), + y: self.y.outside(®ion.y), + } + } + + pub fn axis_mut(&mut self, axis: Axis) -> &mut UiScalar { + match axis { + Axis::X => &mut self.x, + Axis::Y => &mut self.y, + } + } + + pub fn axis(&self, axis: Axis) -> UiScalar { + match axis { + Axis::X => self.x, + Axis::Y => self.y, + } + } + + pub fn to_abs(&self, rel: Vec2) -> Vec2 { + Vec2 { + x: self.x.to_abs(rel.x), + y: self.y.to_abs(rel.y), + } + } + + pub const FULL_SIZE: Self = Self::rel(Vec2::ONE); + + pub const fn from_axis(axis: Axis, aligned: UiScalar, ortho: UiScalar) -> Self { + match axis { + Axis::X => Self { + x: aligned, + y: ortho, + }, + Axis::Y => Self { + x: ortho, + y: aligned, + }, + } + } + + pub fn get_abs(&self) -> Vec2 { + (self.x.abs, self.y.abs).into() + } + + pub fn get_rel(&self) -> Vec2 { + (self.x.rel, self.y.rel).into() + } + + pub fn abs_mut(&mut self) -> Vec2View<'_> { + Vec2View { + x: &mut self.x.abs, + y: &mut self.y.abs, + } + } +} + +impl Display for UiVec2 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "rel{};abs{}", self.get_rel(), self.get_abs()) + } +} + +impl_op!(UiVec2 Add add; x y); +impl_op!(UiVec2 Sub sub; x y); + +impl const From for UiVec2 { + fn from(abs: Vec2) -> Self { + Self::abs(abs) + } +} + +impl const From<(T, U)> for UiVec2 +where + (T, U): const Destruct, +{ + fn from(abs: (T, U)) -> Self { + Self::abs(abs) + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, Default, bytemuck::Zeroable)] +pub struct UiScalar { + pub rel: f32, + pub abs: f32, +} + +impl Eq for UiScalar {} +impl Hash for UiScalar { + fn hash(&self, state: &mut H) { + state.write_u32(self.rel.to_bits()); + state.write_u32(self.abs.to_bits()); + } +} + +impl_op!(UiScalar Add add; rel abs); +impl_op!(UiScalar Sub sub; rel abs); + +impl UiScalar { + pub const ZERO: Self = Self { rel: 0.0, abs: 0.0 }; + pub const FULL: Self = Self { rel: 1.0, abs: 0.0 }; + + pub const fn new(rel: f32, abs: f32) -> Self { + Self { rel, abs } + } + + pub const fn rel(rel: f32) -> Self { + Self { rel, abs: 0.0 } + } + + pub const fn abs(abs: f32) -> Self { + Self { rel: 0.0, abs } + } + + pub const fn rel_min() -> Self { + Self::new(0.0, 0.0) + } + + pub const fn rel_max() -> Self { + Self::new(1.0, 0.0) + } + + pub const fn max(&self, other: Self) -> Self { + Self { + rel: self.rel.max(other.rel), + abs: self.abs.max(other.abs), + } + } + + pub const fn min(&self, other: Self) -> Self { + Self { + rel: self.rel.min(other.rel), + abs: self.abs.min(other.abs), + } + } + + pub const fn offset(mut self, amt: f32) -> Self { + self.abs += amt; + self + } + + pub const fn within(&self, span: &UiSpan) -> Self { + let anchor = self.rel.lerp(span.start.rel, span.end.rel); + let offset = self.abs + self.rel.lerp(span.start.abs, span.end.abs); + Self { + rel: anchor, + abs: offset, + } + } + + pub const fn outside(&self, span: &UiSpan) -> Self { + let rel = self.rel.lerp_inv(span.start.rel, span.end.rel); + let abs = self.abs - rel.lerp(span.start.abs, span.end.abs); + Self { rel, abs } + } + + pub fn within_len(&self, len: UiScalar) -> Self { + self.within(&UiSpan { + start: UiScalar::ZERO, + end: len, + }) + } + + pub fn select_len(&self, len: UiScalar) -> Self { + len.within_len(*self) + } + + pub const fn flip(&mut self) { + self.rel = 1.0 - self.rel; + self.abs = -self.abs; + } + + pub const fn to(&self, end: Self) -> UiSpan { + UiSpan { start: *self, end } + } + + pub const fn to_abs(&self, rel: f32) -> f32 { + self.rel * rel + self.abs + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)] +pub struct UiSpan { + pub start: UiScalar, + pub end: UiScalar, +} + +impl UiSpan { + pub const FULL: Self = Self { + start: UiScalar::ZERO, + end: UiScalar::FULL, + }; + + pub const fn rel(rel: f32) -> Self { + Self { + start: UiScalar::rel(rel), + end: UiScalar::rel(rel), + } + } + + pub const fn new(start: UiScalar, end: UiScalar) -> Self { + Self { start, end } + } + + pub const fn flip(&mut self) { + self.start.flip(); + self.end.flip(); + std::mem::swap(&mut self.start.rel, &mut self.end.rel); + std::mem::swap(&mut self.start.abs, &mut self.end.abs); + } + + pub const fn shift(&mut self, offset: UiScalar) { + self.start += offset; + self.end += offset; + } + + pub const fn within(&self, parent: &Self) -> Self { + Self { + start: self.start.within(parent), + end: self.end.within(parent), + } + } + + pub const fn outside(&self, parent: &Self) -> Self { + Self { + start: self.start.outside(parent), + end: self.end.outside(parent), + } + } + + pub const fn len(&self) -> UiScalar { + self.end - self.start + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)] +pub struct UiRegion { + pub x: UiSpan, + pub y: UiSpan, +} + +impl UiRegion { + pub const FULL: Self = Self { + x: UiSpan::FULL, + y: UiSpan::FULL, + }; + + pub const fn new(x: UiSpan, y: UiSpan) -> Self { + Self { x, y } + } + + pub const fn rel(rel: Vec2) -> Self { + Self { + x: UiSpan::rel(rel.x), + y: UiSpan::rel(rel.y), + } + } + pub const fn within(&self, parent: &Self) -> Self { + Self { + x: self.x.within(&parent.x), + y: self.y.within(&parent.y), + } + } + pub const fn outside(&self, parent: &Self) -> Self { + Self { + x: self.x.outside(&parent.x), + y: self.y.outside(&parent.y), + } + } + + pub const fn axis(&mut self, axis: Axis) -> &UiSpan { + match axis { + Axis::X => &self.x, + Axis::Y => &self.y, + } + } + + pub const fn axis_mut(&mut self, axis: Axis) -> &mut UiSpan { + match axis { + Axis::X => &mut self.x, + Axis::Y => &mut self.y, + } + } + + pub const fn flip(&mut self, axis: Axis) { + match axis { + Axis::X => self.x.flip(), + Axis::Y => self.y.flip(), + } + } + + pub fn shift(&mut self, offset: impl Into) { + let offset = offset.into(); + self.x.shift(offset.x); + self.y.shift(offset.y); + } + + pub fn offset(mut self, offset: impl Into) -> Self { + self.shift(offset); + self + } + + pub fn to_px(&self, size: Vec2) -> PixelRegion { + PixelRegion { + top_left: self.top_left().get_rel() * size + self.top_left().get_abs(), + bot_right: self.bot_right().get_rel() * size + self.bot_right().get_abs(), + } + } + + pub const fn center(&self) -> UiVec2 { + Align::CENTER.pos().within(self) + } + + pub const fn size(&self) -> UiVec2 { + UiVec2 { + x: self.x.len(), + y: self.y.len(), + } + } + + pub const fn top_left(&self) -> UiVec2 { + UiVec2 { + x: self.x.start, + y: self.y.start, + } + } + + pub const fn bot_right(&self) -> UiVec2 { + UiVec2 { + x: self.x.end, + y: self.y.end, + } + } + + pub const fn from_axis(axis: Axis, aligned: UiSpan, ortho: UiSpan) -> Self { + Self { + x: match axis { + Axis::X => aligned, + Axis::Y => ortho, + }, + y: match axis { + Axis::X => ortho, + Axis::Y => aligned, + }, + } + } +} + +impl Display for UiRegion { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "{} -> {} (size: {})", + self.top_left(), + self.bot_right(), + self.size() + ) + } +} + +#[derive(Debug)] +pub struct PixelRegion { + pub top_left: Vec2, + pub bot_right: Vec2, +} + +impl PixelRegion { + pub fn contains(&self, pos: Vec2) -> bool { + pos.x >= self.top_left.x + && pos.x <= self.bot_right.x + && pos.y >= self.top_left.y + && pos.y <= self.bot_right.y + } + + pub fn size(&self) -> Vec2 { + self.bot_right - self.top_left + } +} + +impl Display for PixelRegion { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{} -> {}", self.top_left, self.bot_right) + } +} + +pub struct Vec2View<'a> { + pub x: &'a mut f32, + pub y: &'a mut f32, +} + +impl Vec2View<'_> { + pub fn set(&mut self, other: Vec2) { + *self.x = other.x; + *self.y = other.y; + } + + pub fn add(&mut self, other: Vec2) { + *self.x += other.x; + *self.y += other.y; + } +} diff --git a/iris/core/src/primitive/color.rs b/iris/core/src/primitive/color.rs new file mode 100644 index 0000000..1681c2b --- /dev/null +++ b/iris/core/src/primitive/color.rs @@ -0,0 +1,163 @@ +use std::marker::Destruct; + +/// stored in linear for sane manipulation +#[repr(C)] +#[derive(Clone, Copy, Hash, PartialEq, Eq, bytemuck::Zeroable, Debug)] +pub struct Color { + pub r: T, + pub g: T, + pub b: T, + pub a: T, +} + +impl Color { + pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN); + pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX); + pub const GRAY: Self = Self::rgb(T::MID, T::MID, T::MID); + + pub const RED: Self = Self::rgb(T::MAX, T::MIN, T::MIN); + pub const ORANGE: Self = Self::rgb(T::MAX, T::MID, T::MIN); + pub const YELLOW: Self = Self::rgb(T::MAX, T::MAX, T::MIN); + pub const LIME: Self = Self::rgb(T::MID, T::MAX, T::MIN); + pub const GREEN: Self = Self::rgb(T::MIN, T::MAX, T::MIN); + pub const TURQUOISE: Self = Self::rgb(T::MIN, T::MAX, T::MID); + pub const CYAN: Self = Self::rgb(T::MIN, T::MAX, T::MAX); + pub const SKY: Self = Self::rgb(T::MIN, T::MID, T::MAX); + pub const BLUE: Self = Self::rgb(T::MIN, T::MIN, T::MAX); + pub const PURPLE: Self = Self::rgb(T::MID, T::MIN, T::MAX); + pub const MAGENTA: Self = Self::rgb(T::MAX, T::MIN, T::MAX); + + pub const NONE: Self = Self::new(T::MIN, T::MIN, T::MIN, T::MIN); + + pub const fn new(r: T, g: T, b: T, a: T) -> Self { + Self { r, g, b, a } + } + pub const fn rgb(r: T, g: T, b: T) -> Self { + Self { r, g, b, a: T::MAX } + } + pub fn alpha(mut self, a: T) -> Self { + self.a = a; + self + } + + pub fn as_arr(self) -> [T; 4] { + [self.r, self.g, self.b, self.a] + } +} + +pub const trait F32Conversion { + fn to(self) -> f32; + fn from(x: f32) -> Self; +} + +pub trait ColorNum { + const MIN: Self; + const MID: Self; + const MAX: Self; +} + +macro_rules! map_rgb { + ($x:ident,$self:ident, $e:tt) => { + #[allow(unused_braces)] + Self { + r: { + let $x = $self.r; + $e + }, + g: { + let $x = $self.g; + $e + }, + b: { + let $x = $self.b; + $e + }, + a: $self.a, + } + }; +} + +impl Color +where + Self: const Destruct, +{ + pub const fn mul_rgb(self, amt: impl const F32Conversion) -> Self { + let amt = amt.to(); + map_rgb!(x, self, { T::from(x.to() * amt) }) + } + + pub const fn add_rgb(self, amt: impl const F32Conversion) -> Self { + let amt = amt.to(); + map_rgb!(x, self, { T::from(x.to() + amt) }) + } + + pub const fn darker(self, amt: f32) -> Self { + self.mul_rgb(1.0 - amt) + } + + pub const fn brighter(self, amt: f32) -> Self { + map_rgb!(x, self, { + let x = x.to(); + T::from(x + (1.0 - x) * amt) + }) + } + + pub fn map_rgb(self, f: impl Fn(T) -> T) -> Self { + Self { + r: f(self.r), + g: f(self.g), + b: f(self.b), + a: self.a, + } + } + + pub fn srgb(r: T, g: T, b: T) -> Self { + Self { + r: s_to_l(r), + g: s_to_l(g), + b: s_to_l(b), + a: T::MAX, + } + } +} + +fn s_to_l(x: T) -> T { + let x = x.to(); + T::from(if x <= 0.0405 { + x / 12.92 + } else { + ((x + 0.055) / 1.055).powf(2.4) + }) +} + +impl ColorNum for u8 { + const MIN: Self = u8::MIN; + const MID: Self = u8::MAX / 2; + const MAX: Self = u8::MAX; +} + +impl ColorNum for f32 { + const MIN: Self = 0.0; + const MID: Self = 0.5; + const MAX: Self = 1.0; +} + +unsafe impl bytemuck::Pod for Color {} + +impl const F32Conversion for f32 { + fn to(self) -> f32 { + self + } + fn from(x: f32) -> Self { + x + } +} + +impl const F32Conversion for u8 { + fn to(self) -> f32 { + self as f32 / 255.0 + } + fn from(x: f32) -> Self { + (x * 255.0).clamp(0.0, 255.0) as Self + } +} diff --git a/iris/core/src/primitive/layer.rs b/iris/core/src/primitive/layer.rs new file mode 100644 index 0000000..54f6a96 --- /dev/null +++ b/iris/core/src/primitive/layer.rs @@ -0,0 +1,275 @@ +use std::ops::{Index, IndexMut}; + +use crate::{ + render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives}, + util::to_mut, +}; + +pub type LayerId = usize; + +struct LayerNode { + next: Ptr, + prev: Ptr, + child: Option, + depth: usize, + data: T, +} + +#[derive(Clone, Copy, Debug)] +enum Ptr { + /// continue on same level + Next(usize), + /// go back to parent + Parent(usize), + /// end + None, +} + +/// TODO: currently this does not ever free layers +/// is that realistically desired? +pub struct Layers { + vec: Vec>, + /// index of last layer at top level (start at first = 0) + last: usize, +} + +#[derive(Clone, Copy)] +struct Child { + head: usize, + tail: usize, +} + +pub type PrimitiveLayers = Layers; + +impl Layers { + pub fn new() -> Layers { + Self { + vec: vec![LayerNode::head()], + last: 0, + } + } + + pub fn clear(&mut self) { + self.vec.clear(); + self.vec.push(LayerNode::head()); + } + + fn push(&mut self, node: LayerNode) -> LayerId { + let i = self.vec.len(); + self.vec.push(node); + i + } + + pub fn next(&mut self, i: LayerId) -> LayerId { + if let Ptr::Next(i) = self.vec[i].next { + return i; + } + let i_new = self.push(LayerNode::new( + T::default(), + self.vec[i].next, + Ptr::Next(i), + self.vec[i].depth, + )); + self.vec[i].next = Ptr::Next(i_new); + self.vec[i_new].prev = Ptr::Next(i); + match self.vec[i_new].next { + Ptr::Next(i) => self.vec[i].prev = Ptr::Next(i_new), + Ptr::Parent(i) => self.vec[i].child.as_mut().unwrap().tail = i_new, + Ptr::None => self.last = i_new, + } + i_new + } + + pub fn child(&mut self, i: LayerId) -> LayerId { + if let Some(c) = self.vec[i].child { + return c.head; + } + let i_child = self.push(LayerNode::new( + T::default(), + Ptr::Parent(i), + Ptr::Parent(i), + self.vec[i].depth + 1, + )); + self.vec[i].child = Some(Child { + head: i_child, + tail: i_child, + }); + i_child + } + + pub fn iter_mut(&mut self) -> LayerIteratorMut<'_, T> { + LayerIteratorMut::new(&mut self.vec, self.last) + } + + pub fn iter_orderless_mut(&mut self) -> impl Iterator { + self.vec.iter_mut().map(|n| &mut n.data).enumerate() + } + + pub fn iter(&self) -> impl Iterator { + self.indices().map(|i| (i, &self.vec[i].data)) + } + + pub fn iter_depth(&self) -> impl Iterator { + self.indices() + .map(|i| ((i, self.vec[i].depth), &self.vec[i].data)) + } + + pub fn indices(&self) -> LayerIndexIterator<'_, T> { + LayerIndexIterator::new(&self.vec, self.last) + } +} + +impl PrimitiveLayers { + pub fn write( + &mut self, + layer: LayerId, + info: PrimitiveInst

, + ) -> PrimitiveHandle { + self[layer].write(layer, info) + } + + pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx { + self[h.layer].free(h) + } +} + +impl Default for Layers { + fn default() -> Self { + Self::new() + } +} + +impl Index for Layers { + type Output = T; + + fn index(&self, index: LayerId) -> &Self::Output { + &self.vec[index].data + } +} + +impl IndexMut for Layers { + fn index_mut(&mut self, index: LayerId) -> &mut Self::Output { + &mut self.vec[index].data + } +} + +impl LayerNode { + pub fn new(data: T, next: Ptr, prev: Ptr, depth: usize) -> Self { + Self { + next, + prev, + child: None, + data, + depth, + } + } + + pub fn head() -> Self { + Self::new(T::default(), Ptr::None, Ptr::None, 0) + } +} + +pub struct LayerIteratorMut<'a, T> { + inner: LayerIndexIterator<'a, T>, +} + +impl<'a, T> Iterator for LayerIteratorMut<'a, T> { + type Item = (usize, &'a mut T); + + fn next(&mut self) -> Option { + let i = self.inner.next()?; + // SAFETY: requires index iterator to work properly + let layer = unsafe { to_mut(&self.inner.vec[i].data) }; + Some((i, layer)) + } +} + +impl<'a, T> DoubleEndedIterator for LayerIteratorMut<'a, T> { + fn next_back(&mut self) -> Option { + let i = self.inner.next_back()?; + // SAFETY: requires index iterator to work properly + let layer = unsafe { to_mut(&self.inner.vec[i].data) }; + Some((i, layer)) + } +} + +impl<'a, T> LayerIteratorMut<'a, T> { + fn new(vec: &'a mut Vec>, last: usize) -> Self { + Self { + inner: LayerIndexIterator::new(vec, last), + } + } +} + +pub struct LayerIndexIterator<'a, T> { + next: Option, + next_back: Option, + vec: &'a Vec>, +} + +impl<'a, T> Iterator for LayerIndexIterator<'a, T> { + type Item = usize; + + fn next(&mut self) -> Option { + let ret_i = self.next?; + let node = &self.vec[ret_i]; + self.next = if let Some(c) = node.child { + Some(c.head) + } else if let Ptr::Next(i) = node.next { + Some(i) + } else if let Ptr::Parent(i) = node.next { + let mut node = &self.vec[i]; + while let Ptr::Parent(i) = node.next { + node = &self.vec[i]; + } + if let Ptr::Next(i) = node.next { + Some(i) + } else { + None + } + } else { + None + }; + if self.next_back.unwrap() == ret_i { + self.next = None; + self.next_back = None; + } + Some(ret_i) + } +} + +impl<'a, T> DoubleEndedIterator for LayerIndexIterator<'a, T> { + fn next_back(&mut self) -> Option { + let ret_i = self.next_back?; + let node = &self.vec[ret_i]; + self.next_back = if let Ptr::Next(mut i) = node.prev { + while let Some(c) = self.vec[i].child { + i = c.tail + } + Some(i) + } else if let Ptr::Parent(i) = node.prev { + Some(i) + } else { + None + }; + if self.next.unwrap() == ret_i { + self.next = None; + self.next_back = None; + } + Some(ret_i) + } +} + +impl<'a, T> LayerIndexIterator<'a, T> { + fn new(vec: &'a Vec>, last: usize) -> Self { + let mut last = last; + while let Some(c) = vec[last].child { + last = c.tail; + } + Self { + next: Some(0), + next_back: Some(last), + vec, + } + } +} diff --git a/iris/core/src/primitive/mod.rs b/iris/core/src/primitive/mod.rs new file mode 100644 index 0000000..8284a05 --- /dev/null +++ b/iris/core/src/primitive/mod.rs @@ -0,0 +1,9 @@ +mod color; +mod layer; +mod text; +mod texture; + +pub use color::*; +pub use layer::*; +pub use text::*; +pub use texture::*; diff --git a/iris/core/src/primitive/text.rs b/iris/core/src/primitive/text.rs new file mode 100644 index 0000000..820d1f0 --- /dev/null +++ b/iris/core/src/primitive/text.rs @@ -0,0 +1,191 @@ +use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2}; +use cosmic_text::{ + Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache, + SwashContent, +}; +use image::{DynamicImage, GenericImageView, RgbaImage}; +use std::simd::{Simd, num::SimdUint}; + +/// TODO: properly wrap this +pub mod text_lib { + pub use cosmic_text::*; +} + +pub struct TextData { + pub font_system: FontSystem, + pub swash_cache: SwashCache, + glyph_cache: Vec<(Placement, CacheKey, Color)>, +} + +impl Default for TextData { + fn default() -> Self { + Self { + font_system: FontSystem::new(), + swash_cache: SwashCache::new(), + glyph_cache: Default::default(), + } + } +} + +#[derive(Clone, Copy)] +pub struct TextAttrs { + pub color: UiColor, + pub font_size: f32, + pub line_height: f32, + pub family: Family<'static>, + pub wrap: bool, + /// inner alignment of text region (within where it's drawn) + pub align: RegionAlign, +} + +impl TextAttrs { + pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option) { + buf.set_metrics_and_size( + font_system, + Metrics::new(self.font_size, self.line_height), + width, + None, + ); + let attrs = Attrs::new().family(self.family); + let list = AttrsList::new(&attrs); + for line in &mut buf.lines { + line.set_attrs_list(list.clone()); + } + } +} + +pub type TextBuffer = Buffer; + +impl Default for TextAttrs { + fn default() -> Self { + let size = 16.0; + Self { + color: UiColor::WHITE, + font_size: size, + line_height: size * LINE_HEIGHT_MULT, + family: Family::SansSerif, + wrap: false, + align: Align::CENTER_LEFT, + } + } +} + +pub const LINE_HEIGHT_MULT: f32 = 1.1; + +impl TextData { + pub fn draw( + &mut self, + buffer: &mut TextBuffer, + attrs: &TextAttrs, + textures: &mut Textures, + ) -> RenderedText { + // TODO: either this or the layout stuff (or both) is super slow, + // should probably do texture packing and things if possible. + // very visible if you add just a couple of wrapping texts and resize window + // should also be timed to figure out exactly what points need to be sped up + // let mut pixels = HashMap::<_, [u8; 4]>::default(); + let mut min_x = 0; + let mut min_y = 0; + let mut max_x = 0; + let mut max_y = 0; + let text_color = { + let c = attrs.color; + cosmic_text::Color::rgba(c.r, c.g, c.b, c.a) + }; + let mut max_width = 0.0f32; + let mut height = 0.0; + + for run in buffer.layout_runs() { + for glyph in run.glyphs.iter() { + let physical_glyph = glyph.physical((0., 0.), 1.0); + + let glyph_color = match glyph.color_opt { + Some(some) => some, + None => text_color, + }; + + if let Some(img) = self + .swash_cache + .get_image(&mut self.font_system, physical_glyph.cache_key) + { + let mut pos = img.placement; + pos.left += physical_glyph.x; + pos.top = physical_glyph.y + run.line_y as i32 - pos.top; + min_x = min_x.min(pos.left); + min_y = min_y.min(pos.top); + max_x = max_x.max(pos.left + pos.width as i32); + max_y = max_y.max(pos.top + pos.height as i32); + self.glyph_cache + .push((pos, physical_glyph.cache_key, glyph_color)); + } + } + max_width = max_width.max(run.line_w); + height += run.line_height; + } + let img_width = (max_x - min_x + 1) as u32; + let img_height = (max_y - min_y + 1) as u32; + let mut image = RgbaImage::new(img_width, img_height); + + for (pos, key, color) in self.glyph_cache.drain(..) { + let img = self + .swash_cache + .get_image(&mut self.font_system, key) + .as_ref() + .unwrap(); + let mut merge = |i, color: [u8; 4]| { + let i = i as i32; + let x = (i % pos.width as i32 + pos.left - min_x) as u32; + let y = (i / pos.width as i32 + pos.top - min_y) as u32; + let pixel = &mut image[(x, y)].0; + // TODO: no clue if proper alpha blending should be done + *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into(); + }; + + match img.content { + SwashContent::Mask => { + for (i, a) in img.data.iter().enumerate() { + let mut color = color.as_rgba(); + color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8; + merge(i, color); + } + } + SwashContent::SubpixelMask => todo!("subpixel mask text rendering"), + SwashContent::Color => { + let (colors, _) = img.data.as_chunks::<4>(); + for (i, color) in colors.iter().enumerate() { + merge(i, *color); + } + } + } + } + + let max_dim = 8192; + if image.width() > max_dim || image.height() > max_dim { + let width = image.width().min(max_dim); + let height = image.height().min(max_dim); + eprintln!( + "WARNING: image of size {:?} cropped to {:?} (texture too big)", + image.dimensions(), + (width, height) + ); + image = image.view(0, 0, width, height).to_image(); + } + + RenderedText { + handle: textures.add(image), + top_left_offset: Vec2::new(min_x as f32, min_y as f32), + size: Vec2::new(max_width, height), + } + } +} + +#[derive(Clone)] +pub struct RenderedText { + pub handle: TextureHandle, + pub top_left_offset: Vec2, + pub size: Vec2, +} + +pub trait HasTextures { + fn add_texture(&mut self, image: DynamicImage) -> TextureHandle; +} diff --git a/iris/core/src/primitive/texture.rs b/iris/core/src/primitive/texture.rs new file mode 100644 index 0000000..74e3bf0 --- /dev/null +++ b/iris/core/src/primitive/texture.rs @@ -0,0 +1,136 @@ +use crate::{ + render::TexturePrimitive, + util::{RefCounter, Vec2}, +}; +use image::{DynamicImage, GenericImageView}; +use std::{ + ops::Index, + sync::mpsc::{Receiver, Sender, channel}, +}; + +#[derive(Debug, Clone)] +pub struct TextureHandle { + inner: TexturePrimitive, + size: Vec2, + counter: RefCounter, + send: Sender, +} + +/// a texture manager for a ui +/// note that this is heavily oriented towards wgpu's renderer so the primitives don't need mapped +pub struct Textures { + free: Vec, + images: Vec>, + updates: Vec, + send: Sender, + recv: Receiver, +} + +pub enum TextureUpdate<'a> { + Push(&'a DynamicImage), + Set(u32, &'a DynamicImage), + Free(u32), + PushFree, + SetFree, +} + +enum Update { + Push(u32), + Set(u32), + Free(u32), +} + +impl Textures { + pub fn new() -> Self { + let (send, recv) = channel(); + Self { + free: Vec::new(), + images: Vec::new(), + updates: Vec::new(), + send, + recv, + } + } + pub fn add(&mut self, image: impl Into) -> TextureHandle { + let image = image.into(); + let size = image.dimensions().into(); + let view_idx = self.push(image); + // 0 == default in renderer; TODO: actually create samplers here + let sampler_idx = 0; + TextureHandle { + inner: TexturePrimitive { + view_idx, + sampler_idx, + }, + size, + counter: RefCounter::new(), + send: self.send.clone(), + } + } + + fn push(&mut self, image: DynamicImage) -> u32 { + if let Some(i) = self.free.pop() { + self.images[i as usize] = Some(image); + self.updates.push(Update::Set(i)); + i + } else { + let i = self.images.len() as u32; + self.images.push(Some(image)); + self.updates.push(Update::Push(i)); + i + } + } + + pub fn free(&mut self) { + for idx in self.recv.try_iter() { + self.images[idx as usize] = None; + self.updates.push(Update::Free(idx)); + self.free.push(idx); + } + } + + pub fn updates(&mut self) -> impl Iterator> { + self.updates.drain(..).map(|u| match u { + Update::Push(i) => self.images[i as usize] + .as_ref() + .map(TextureUpdate::Push) + .unwrap_or(TextureUpdate::PushFree), + Update::Set(i) => self.images[i as usize] + .as_ref() + .map(|img| TextureUpdate::Set(i, img)) + .unwrap_or(TextureUpdate::SetFree), + Update::Free(i) => TextureUpdate::Free(i), + }) + } +} + +impl TextureHandle { + pub fn primitive(&self) -> TexturePrimitive { + self.inner + } + pub fn size(&self) -> Vec2 { + self.size + } +} + +impl Drop for TextureHandle { + fn drop(&mut self) { + if self.counter.drop() { + let _ = self.send.send(self.inner.view_idx); + } + } +} + +impl Index<&TextureHandle> for Textures { + type Output = DynamicImage; + + fn index(&self, index: &TextureHandle) -> &Self::Output { + self.images[index.inner.view_idx as usize].as_ref().unwrap() + } +} + +impl Default for Textures { + fn default() -> Self { + Self::new() + } +} diff --git a/iris/core/src/render/data.rs b/iris/core/src/render/data.rs new file mode 100644 index 0000000..2953065 --- /dev/null +++ b/iris/core/src/render/data.rs @@ -0,0 +1,50 @@ +use crate::{UiRegion, util::Id}; +use wgpu::*; + +#[repr(C)] +#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Default)] +pub struct WindowUniform { + pub width: f32, + pub height: f32, +} + +#[repr(C)] +#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] +pub struct PrimitiveInstance { + pub region: UiRegion, + pub binding: u32, + pub idx: u32, + pub mask_idx: MaskIdx, +} + +impl PrimitiveInstance { + const ATTRIBS: [VertexAttribute; 7] = vertex_attr_array![ + 0 => Float32x2, + 1 => Float32x2, + 2 => Float32x2, + 3 => Float32x2, + 4 => Uint32, + 5 => Uint32, + 6 => Uint32, + ]; + + pub fn desc() -> VertexBufferLayout<'static> { + VertexBufferLayout { + array_stride: std::mem::size_of::() as BufferAddress, + step_mode: VertexStepMode::Instance, + attributes: &Self::ATTRIBS, + } + } +} + +pub type MaskIdx = Id; + +impl MaskIdx { + pub const NONE: Self = Self::preset(u32::MAX); +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] +pub struct Mask { + pub region: UiRegion, +} diff --git a/iris/core/src/render/mod.rs b/iris/core/src/render/mod.rs new file mode 100644 index 0000000..1695efa --- /dev/null +++ b/iris/core/src/render/mod.rs @@ -0,0 +1,362 @@ +use std::num::NonZero; + +use crate::{ + UiData, UiRenderState, + render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf}, + util::HashMap, +}; +use data::WindowUniform; +use wgpu::{ + util::{BufferInitDescriptor, DeviceExt}, + *, +}; +use winit::dpi::PhysicalSize; + +mod data; +mod primitive; +mod texture; +mod util; + +pub use data::{Mask, MaskIdx}; +pub use primitive::*; + +const SHAPE_SHADER: &str = include_str!("./shader.wgsl"); + +pub struct UiRenderNode { + uniform_group: BindGroup, + primitive_layout: BindGroupLayout, + rsc_layout: BindGroupLayout, + rsc_group: BindGroup, + + pipeline: RenderPipeline, + + layers: HashMap, + active: Vec, + window_buffer: Buffer, + textures: GpuTextures, + masks: ArrBuf, +} + +struct RenderLayer { + instance: ArrBuf, + primitives: PrimitiveBuffers, + primitive_group: BindGroup, +} + +impl UiRenderNode { + pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) { + pass.set_pipeline(&self.pipeline); + pass.set_bind_group(0, &self.uniform_group, &[]); + pass.set_bind_group(2, &self.rsc_group, &[]); + for i in &self.active { + let layer = &self.layers[i]; + if layer.instance.len() == 0 { + continue; + } + pass.set_bind_group(1, &layer.primitive_group, &[]); + pass.set_vertex_buffer(0, layer.instance.buffer.slice(..)); + pass.draw(0..4, 0..layer.instance.len() as u32); + } + } + + pub fn update( + &mut self, + device: &Device, + queue: &Queue, + ui: &mut UiData, + ui_render: &mut UiRenderState, + ) { + self.active.clear(); + for (i, primitives) in ui_render.layers.iter_mut() { + self.active.push(i); + for change in primitives.apply_free() { + if let Some(inst) = ui_render.active.get_mut(&change.id) { + for h in &mut inst.primitives { + if h.layer == i && h.inst_idx == change.old { + h.inst_idx = change.new; + break; + } + } + } + } + let rlayer = self.layers.entry(i).or_insert_with(|| { + let primitives = PrimitiveBuffers::new(device); + let primitive_group = + Self::primitive_group(device, &self.primitive_layout, primitives.buffers()); + RenderLayer { + instance: ArrBuf::new( + device, + BufferUsages::VERTEX | BufferUsages::COPY_DST, + "instance", + ), + primitives, + primitive_group, + } + }); + if primitives.updated { + rlayer + .instance + .update(device, queue, primitives.instances()); + rlayer.primitives.update(device, queue, primitives.data()); + rlayer.primitive_group = Self::primitive_group( + device, + &self.primitive_layout, + rlayer.primitives.buffers(), + ); + primitives.updated = false; + } + } + let mut changed = false; + changed |= self.textures.update(&mut ui.textures); + if ui.masks.changed { + ui.masks.changed = false; + self.masks.update(device, queue, &ui.masks[..]); + changed = true; + } + if changed { + self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks); + } + } + + pub fn resize(&mut self, size: &PhysicalSize, queue: &Queue) { + let slice = &[WindowUniform { + width: size.width as f32, + height: size.height as f32, + }]; + queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice)); + } + + pub fn new( + device: &Device, + queue: &Queue, + config: &SurfaceConfiguration, + limits: UiLimits, + ) -> Self { + let shader = device.create_shader_module(ShaderModuleDescriptor { + label: Some("UI Shape Shader"), + source: ShaderSource::Wgsl(SHAPE_SHADER.into()), + }); + + let window_uniform = WindowUniform::default(); + let window_buffer = device.create_buffer_init(&BufferInitDescriptor { + label: Some("window"), + contents: bytemuck::cast_slice(&[window_uniform]), + usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST, + }); + + let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor { + entries: &[BindGroupLayoutEntry { + binding: 0, + visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT, + ty: BindingType::Buffer { + ty: BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }], + label: Some("window"), + }); + + let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer); + + let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor { + entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| { + BindGroupLayoutEntry { + binding: i as u32, + visibility: ShaderStages::FRAGMENT, + ty: BindingType::Buffer { + ty: BufferBindingType::Storage { read_only: true }, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + } + }), + label: Some("primitive"), + }); + + let tex_manager = GpuTextures::new(device, queue); + let masks = ArrBuf::new( + device, + BufferUsages::STORAGE | BufferUsages::COPY_DST, + "ui masks", + ); + + let rsc_layout = Self::rsc_layout(device, &limits); + let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks); + + let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor { + label: Some("UI Shape Pipeline Layout"), + bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout], + immediate_size: 0, + }); + let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor { + label: Some("UI Shape Pipeline"), + layout: Some(&pipeline_layout), + vertex: VertexState { + module: &shader, + entry_point: Some("vs_main"), + buffers: &[PrimitiveInstance::desc()], + compilation_options: Default::default(), + }, + fragment: Some(FragmentState { + module: &shader, + entry_point: Some("fs_main"), + targets: &[Some(ColorTargetState { + format: config.format, + blend: Some(BlendState::ALPHA_BLENDING), + write_mask: ColorWrites::ALL, + })], + compilation_options: Default::default(), + }), + primitive: PrimitiveState { + topology: PrimitiveTopology::TriangleStrip, + strip_index_format: None, + front_face: FrontFace::Cw, + cull_mode: Some(Face::Back), + polygon_mode: PolygonMode::Fill, + unclipped_depth: false, + conservative: false, + }, + depth_stencil: None, + multisample: MultisampleState { + count: 1, + mask: !0, + alpha_to_coverage_enabled: false, + }, + multiview_mask: None, + cache: None, + }); + + Self { + uniform_group, + primitive_layout, + rsc_layout, + rsc_group, + pipeline, + window_buffer, + layers: HashMap::default(), + active: Vec::new(), + textures: tex_manager, + masks, + } + } + + fn bind_group_0( + device: &Device, + layout: &BindGroupLayout, + window_buffer: &Buffer, + ) -> BindGroup { + device.create_bind_group(&BindGroupDescriptor { + layout, + entries: &[BindGroupEntry { + binding: 0, + resource: window_buffer.as_entire_binding(), + }], + label: Some("ui window"), + }) + } + + fn primitive_group( + device: &Device, + layout: &BindGroupLayout, + buffers: [(u32, &Buffer); PrimitiveBuffers::LEN], + ) -> BindGroup { + device.create_bind_group(&BindGroupDescriptor { + layout, + entries: &buffers.map(|(binding, buf)| BindGroupEntry { + binding, + resource: buf.as_entire_binding(), + }), + label: Some("ui primitives"), + }) + } + + fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout { + device.create_bind_group_layout(&BindGroupLayoutDescriptor { + entries: &[ + BindGroupLayoutEntry { + binding: 0, + visibility: ShaderStages::FRAGMENT, + ty: BindingType::Texture { + sample_type: TextureSampleType::Float { filterable: false }, + view_dimension: TextureViewDimension::D2, + multisampled: false, + }, + count: Some(NonZero::new(limits.max_textures).unwrap()), + }, + BindGroupLayoutEntry { + binding: 1, + visibility: ShaderStages::FRAGMENT, + ty: BindingType::Sampler(SamplerBindingType::NonFiltering), + count: Some(NonZero::new(limits.max_samplers).unwrap()), + }, + BindGroupLayoutEntry { + binding: 2, + visibility: ShaderStages::FRAGMENT, + ty: BindingType::Buffer { + ty: BufferBindingType::Storage { read_only: true }, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }, + ], + label: Some("ui rsc"), + }) + } + + fn rsc_group( + device: &Device, + layout: &BindGroupLayout, + tex_manager: &GpuTextures, + masks: &ArrBuf, + ) -> BindGroup { + device.create_bind_group(&BindGroupDescriptor { + layout, + entries: &[ + BindGroupEntry { + binding: 0, + resource: BindingResource::TextureViewArray(&tex_manager.views()), + }, + BindGroupEntry { + binding: 1, + resource: BindingResource::SamplerArray(&tex_manager.samplers()), + }, + BindGroupEntry { + binding: 2, + resource: masks.buffer.as_entire_binding(), + }, + ], + label: Some("ui rsc"), + }) + } + + pub fn view_count(&self) -> usize { + self.textures.view_count() + } +} + +pub struct UiLimits { + max_textures: u32, + max_samplers: u32, +} + +impl Default for UiLimits { + fn default() -> Self { + Self { + max_textures: 100000, + max_samplers: 1000, + } + } +} + +impl UiLimits { + pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 { + self.max_textures + self.max_samplers + } + pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 { + self.max_samplers + } +} diff --git a/iris/core/src/render/primitive.rs b/iris/core/src/render/primitive.rs new file mode 100644 index 0000000..f8f1069 --- /dev/null +++ b/iris/core/src/render/primitive.rs @@ -0,0 +1,282 @@ +use std::ops::{Deref, DerefMut}; + +use crate::{ + Color, UiRegion, WidgetId, + render::{ + ArrBuf, + data::{MaskIdx, PrimitiveInstance}, + }, +}; +use bytemuck::Pod; +use wgpu::*; + +pub struct Primitives { + instances: Vec, + assoc: Vec, + data: PrimitiveData, + free: Vec, + pub updated: bool, +} + +impl Default for Primitives { + fn default() -> Self { + Self { + instances: Default::default(), + assoc: Default::default(), + data: Default::default(), + free: Vec::new(), + updated: true, + } + } +} + +pub trait Primitive: Pod { + const BINDING: u32; + fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec; +} + +macro_rules! primitives { + ($($name:ident: $ty:ty => $binding:expr,)*) => { + #[derive(Default)] + pub struct PrimitiveData { + $(pub(crate) $name: PrimitiveVec<$ty>,)* + } + + pub struct PrimitiveBuffers { + $($name: ArrBuf<$ty>,)* + } + + impl PrimitiveBuffers { + pub fn update(&mut self, device: &Device, queue: &Queue, data: &PrimitiveData) { + $(self.$name.update(device, queue, &data.$name);)* + } + } + + impl PrimitiveBuffers { + pub const LEN: usize = primitives!(@count $($name)*); + pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] { + [ + $((<$ty>::BINDING, &self.$name.buffer),)* + ] + } + pub fn new(device: &Device) -> Self { + Self { + $($name: ArrBuf::new( + device, + BufferUsages::STORAGE | BufferUsages::COPY_DST, + stringify!($name), + ),)* + } + } + } + + impl PrimitiveData { + pub fn clear(&mut self) { + $(self.$name.clear();)* + } + pub fn free(&mut self, binding: u32, idx: usize) { + match binding { + $(<$ty>::BINDING => self.$name.free(idx),)* + _ => unreachable!() + } + } + } + + $( + unsafe impl bytemuck::Pod for $ty {} + unsafe impl bytemuck::Zeroable for $ty {} + impl Primitive for $ty { + const BINDING: u32 = $binding; + fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec { + &mut data.$name + } + } + )* + }; + (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t),+) }; + (@count $t:tt) => { 1 }; +} + +pub struct PrimitiveInst

{ + pub id: WidgetId, + pub primitive: P, + pub region: UiRegion, + pub mask_idx: MaskIdx, +} + +impl Primitives { + pub fn write( + &mut self, + layer: usize, + PrimitiveInst { + id, + primitive, + region, + mask_idx, + }: PrimitiveInst

, + ) -> PrimitiveHandle { + self.updated = true; + let vec = P::vec(&mut self.data); + let i = vec.add(primitive); + let inst = PrimitiveInstance { + region, + idx: i as u32, + mask_idx, + binding: P::BINDING, + }; + let inst_i = if let Some(i) = self.free.pop() { + self.instances[i] = inst; + self.assoc[i] = id; + i + } else { + let i = self.instances.len(); + self.instances.push(inst); + self.assoc.push(id); + i + }; + PrimitiveHandle::new::

(layer, inst_i, i) + } + + /// returns (old index, new index) + pub fn apply_free(&mut self) -> impl Iterator { + self.free.sort_by(|a, b| b.cmp(a)); + self.free.drain(..).filter_map(|i| { + self.instances.swap_remove(i); + self.assoc.swap_remove(i); + if i == self.instances.len() { + return None; + } + let id = self.assoc[i]; + let old = self.instances.len(); + Some(PrimitiveChange { id, old, new: i }) + }) + } + + pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx { + self.updated = true; + self.data.free(h.binding, h.data_idx); + self.free.push(h.inst_idx); + self.instances[h.inst_idx].mask_idx + } + + pub fn data(&self) -> &PrimitiveData { + &self.data + } + + pub fn instances(&self) -> &Vec { + &self.instances + } + + pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion { + self.updated = true; + &mut self.instances[h.inst_idx].region + } +} + +pub struct PrimitiveChange { + pub id: WidgetId, + pub old: usize, + pub new: usize, +} + +#[derive(Debug)] +pub struct PrimitiveHandle { + pub layer: usize, + pub inst_idx: usize, + pub data_idx: usize, + pub binding: u32, +} + +impl PrimitiveHandle { + fn new(layer: usize, inst_idx: usize, data_idx: usize) -> Self { + Self { + layer, + inst_idx, + data_idx, + binding: P::BINDING, + } + } +} + +primitives!( + rects: RectPrimitive => 0, + textures: TexturePrimitive => 1, +); + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RectPrimitive { + pub color: Color, + pub radius: f32, + pub thickness: f32, + pub inner_radius: f32, +} + +impl RectPrimitive { + pub fn color(color: Color) -> Self { + Self { + color, + radius: 0.0, + thickness: 0.0, + inner_radius: 0.0, + } + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct TexturePrimitive { + pub view_idx: u32, + pub sampler_idx: u32, +} + +pub struct PrimitiveVec { + vec: Vec, + free: Vec, +} + +impl PrimitiveVec { + pub fn new() -> Self { + Self { + vec: Vec::new(), + free: Vec::new(), + } + } + pub fn add(&mut self, t: T) -> usize { + if let Some(i) = self.free.pop() { + self.vec[i] = t; + i + } else { + let i = self.vec.len(); + self.vec.push(t); + i + } + } + pub fn free(&mut self, i: usize) { + self.free.push(i); + } + pub fn clear(&mut self) { + self.free.clear(); + self.vec.clear(); + } +} + +impl Default for PrimitiveVec { + fn default() -> Self { + Self::new() + } +} + +impl Deref for PrimitiveVec { + type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.vec + } +} + +impl DerefMut for PrimitiveVec { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.vec + } +} diff --git a/iris/core/src/render/shader.wgsl b/iris/core/src/render/shader.wgsl new file mode 100644 index 0000000..197d101 --- /dev/null +++ b/iris/core/src/render/shader.wgsl @@ -0,0 +1,178 @@ +const RECT: u32 = 0u; +const TEXTURE: u32 = 1u; + +@group(0) @binding(0) +var window: WindowUniform; +@group(1) @binding(RECT) +var rects: array; +@group(1) @binding(TEXTURE) +var textures: array; + +struct Rect { + color: u32, + radius: f32, + thickness: f32, + inner_radius: f32, +} + +struct TextureInfo { + view_idx: u32, + sampler_idx: u32, +} + +struct Mask { + x: UiSpan, + y: UiSpan, +} + +struct UiSpan { + start: UiScalar, + end: UiScalar, +} + +struct UiScalar { + rel: f32, + abs: f32, +} + +struct UiVec2 { + rel: vec2, + abs: vec2, +} + +@group(2) @binding(0) +var views: binding_array>; +@group(2) @binding(1) +var samplers: binding_array; +@group(2) @binding(2) +var masks: array; + +struct WindowUniform { + dim: vec2, +}; + +struct InstanceInput { + @location(0) x_start: vec2, + @location(1) x_end: vec2, + @location(2) y_start: vec2, + @location(3) y_end: vec2, + @location(4) binding: u32, + @location(5) idx: u32, + @location(6) mask_idx: u32, +} + +struct VertexOutput { + @location(0) top_left: vec2, + @location(1) bot_right: vec2, + @location(2) uv: vec2, + @location(3) binding: u32, + @location(4) idx: u32, + @location(5) mask_idx: u32, + @builtin(position) clip_position: vec4, +}; + +struct Region { + pos: vec2, + uv: vec2, + top_left: vec2, + bot_right: vec2, +} + +@vertex +fn vs_main( + @builtin(vertex_index) vi: u32, + in: InstanceInput, +) -> VertexOutput { + var out: VertexOutput; + + let top_left_rel = vec2(in.x_start.x, in.y_start.x); + let top_left_abs = vec2(in.x_start.y, in.y_start.y); + let bot_right_rel = vec2(in.x_end.x, in.y_end.x); + let bot_right_abs = vec2(in.x_end.y, in.y_end.y); + + let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs); + let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs); + let size = bot_right - top_left; + + let uv = vec2( + f32(vi % 2u), + f32(vi / 2u) + ); + let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0; + out.clip_position = vec4(pos.x, -pos.y, 0.0, 1.0); + out.uv = uv; + out.binding = in.binding; + out.idx = in.idx; + out.top_left = top_left; + out.bot_right = bot_right; + out.mask_idx = in.mask_idx; + + return out; +} + +@fragment +fn fs_main( + in: VertexOutput +) -> @location(0) vec4 { + let pos = in.clip_position.xy; + let region = Region(pos, in.uv, in.top_left, in.bot_right); + let i = in.idx; + var color: vec4; + switch in.binding { + case RECT: { + color = draw_rounded_rect(region, rects[i]); + } + case TEXTURE: { + color = draw_texture(region, textures[i]); + } + default: { + color = vec4(1.0, 0.0, 1.0, 1.0); + } + } + if in.mask_idx != 4294967295u { + let mask = masks[in.mask_idx]; + let tl = UiVec2(vec2(mask.x.start.rel, mask.y.start.rel), vec2(mask.x.start.abs, mask.y.start.abs)); + let br = UiVec2(vec2(mask.x.end.rel, mask.y.end.rel), vec2(mask.x.end.abs, mask.y.end.abs)); + + let top_left = floor(tl.rel * window.dim) + floor(tl.abs); + let bot_right = floor(br.rel * window.dim) + floor(br.abs); + if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y { + color *= 0.0; + } + } + return color; +} + +// TODO: this seems really inefficient (per frag indexing)? +fn draw_texture(region: Region, info: TextureInfo) -> vec4 { + return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv); +} + +fn draw_rounded_rect(region: Region, rect: Rect) -> vec4 { + var color = unpack4x8unorm(rect.color); + + let edge = 0.5; + + let size = region.bot_right - region.top_left; + let corner = size / 2.0; + let center = region.top_left + corner; + + let dist = distance_from_rect(region.pos, center, corner, rect.radius); + color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist); + + if rect.thickness > 0.0 { + let dist2 = distance_from_rect(region.pos, center, corner - rect.thickness, rect.inner_radius); + color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2); + } + + return color; +} + +fn distance_from_rect(pixel_pos: vec2, rect_center: vec2, rect_corner: vec2, radius: f32) -> f32 { + // vec from center to pixel + let p = pixel_pos - rect_center; + // vec from inner rect corner to pixel + let q = abs(p) - (rect_corner - radius); + return length(max(q, vec2(0.0))) - radius; +} + diff --git a/iris/core/src/render/texture.rs b/iris/core/src/render/texture.rs new file mode 100644 index 0000000..a9ec637 --- /dev/null +++ b/iris/core/src/render/texture.rs @@ -0,0 +1,129 @@ +use image::{DynamicImage, EncodableLayout}; +use wgpu::{util::DeviceExt, *}; + +use crate::{TextureUpdate, Textures}; + +pub struct GpuTextures { + device: Device, + queue: Queue, + views: Vec, + view_count: usize, + samplers: Vec, + null_view: TextureView, + no_views: Vec, +} + +impl GpuTextures { + pub fn update(&mut self, textures: &mut Textures) -> bool { + let mut changed = false; + for update in textures.updates() { + changed = true; + match update { + TextureUpdate::Push(image) => self.push(image), + TextureUpdate::Set(i, image) => self.set(i, image), + TextureUpdate::SetFree => self.view_count += 1, + TextureUpdate::Free(i) => self.free(i), + TextureUpdate::PushFree => self.push_free(), + } + } + changed + } + fn set(&mut self, i: u32, image: &DynamicImage) { + self.view_count += 1; + let view = self.create_view(image); + self.views[i as usize] = view; + } + fn free(&mut self, i: u32) { + self.view_count -= 1; + self.views[i as usize] = self.null_view.clone(); + } + fn push(&mut self, image: &DynamicImage) { + self.view_count += 1; + let view = self.create_view(image); + self.views.push(view); + } + fn push_free(&mut self) { + self.view_count += 1; + self.views.push(self.null_view.clone()); + } + + fn create_view(&self, image: &DynamicImage) -> TextureView { + let image = image.to_rgba8(); + let (width, height) = image.dimensions(); + let texture = self.device.create_texture_with_data( + &self.queue, + &TextureDescriptor { + label: None, + size: Extent3d { + width, + height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: TextureDimension::D2, + format: TextureFormat::Rgba8Unorm, + usage: TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgt::TextureDataOrder::MipMajor, + image.as_bytes(), + ); + texture.create_view(&TextureViewDescriptor::default()) + } + + pub fn new(device: &Device, queue: &Queue) -> Self { + let null_view = null_texture_view(device); + Self { + device: device.clone(), + queue: queue.clone(), + views: Vec::new(), + samplers: vec![default_sampler(device)], + no_views: vec![null_view.clone()], + null_view, + view_count: 0, + } + } + + pub fn views(&self) -> Vec<&TextureView> { + if self.views.is_empty() { + &self.no_views + } else { + &self.views + } + .iter() + .by_ref() + .collect() + } + + pub fn samplers(&self) -> Vec<&Sampler> { + self.samplers.iter().by_ref().collect() + } + + pub fn view_count(&self) -> usize { + self.view_count + } +} + +pub fn null_texture_view(device: &Device) -> TextureView { + device + .create_texture(&TextureDescriptor { + label: Some("null"), + size: Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: TextureDimension::D2, + format: TextureFormat::Rgba8Unorm, + usage: TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }) + .create_view(&TextureViewDescriptor::default()) +} + +pub fn default_sampler(device: &Device) -> Sampler { + device.create_sampler(&SamplerDescriptor::default()) +} diff --git a/iris/core/src/render/util/mod.rs b/iris/core/src/render/util/mod.rs new file mode 100644 index 0000000..c9d48ff --- /dev/null +++ b/iris/core/src/render/util/mod.rs @@ -0,0 +1,48 @@ +use std::marker::PhantomData; + +use bytemuck::Pod; +use wgpu::*; + +pub struct ArrBuf { + label: &'static str, + usage: BufferUsages, + pub buffer: Buffer, + len: usize, + _pd: PhantomData, +} + +impl ArrBuf { + pub fn new(device: &Device, usage: BufferUsages, label: &'static str) -> Self { + Self { + label, + usage, + buffer: Self::init_buf(device, 0, usage, label), + len: 0, + _pd: PhantomData, + } + } + pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) { + if self.len != data.len() { + self.len = data.len(); + self.buffer = + Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label); + } + queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data)); + } + fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer { + let mut size = size as u64; + if usage.contains(BufferUsages::STORAGE) { + size = size.max(std::mem::size_of::() as u64); + } + device.create_buffer(&BufferDescriptor { + label: Some(label), + size, + mapped_at_creation: false, + usage, + }) + } + #[allow(clippy::len_without_is_empty)] + pub fn len(&self) -> usize { + self.len + } +} diff --git a/iris/core/src/ui/active.rs b/iris/core/src/ui/active.rs new file mode 100644 index 0000000..b2c6ec9 --- /dev/null +++ b/iris/core/src/ui/active.rs @@ -0,0 +1,14 @@ +use crate::{LayerId, MaskIdx, PrimitiveHandle, TextureHandle, UiRegion, WidgetId}; + +/// important non rendering data for retained drawing +#[derive(Debug)] +pub struct ActiveData { + pub id: WidgetId, + pub region: UiRegion, + pub parent: Option, + pub textures: Vec, + pub primitives: Vec, + pub children: Vec, + pub mask: MaskIdx, + pub layer: LayerId, +} diff --git a/iris/core/src/ui/cache.rs b/iris/core/src/ui/cache.rs new file mode 100644 index 0000000..10565ee --- /dev/null +++ b/iris/core/src/ui/cache.rs @@ -0,0 +1,18 @@ +use crate::{BothAxis, Len, UiVec2, WidgetId, util::HashMap}; + +#[derive(Default)] +pub struct Cache { + pub size: BothAxis>, +} + +impl Cache { + pub fn remove(&mut self, id: WidgetId) { + self.size.x.remove(&id); + self.size.y.remove(&id); + } + + pub fn clear(&mut self) { + self.size.x.clear(); + self.size.y.clear(); + } +} diff --git a/iris/core/src/ui/mod.rs b/iris/core/src/ui/mod.rs new file mode 100644 index 0000000..2998cbc --- /dev/null +++ b/iris/core/src/ui/mod.rs @@ -0,0 +1,47 @@ +use crate::{Mask, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena}; + +mod active; +mod cache; +mod painter; +mod render_state; +mod size; + +pub use active::*; +pub use painter::Painter; +pub use render_state::*; +pub use size::*; + +#[derive(Default)] +pub struct UiData { + pub widgets: Widgets, + pub textures: Textures, + pub text: TextData, + pub masks: TrackedArena, +} + +pub trait UiRsc { + fn ui(&self) -> &UiData; + fn ui_mut(&mut self) -> &mut UiData; + + #[allow(unused_variables)] + fn on_add(&mut self, id: WeakWidget) {} + #[allow(unused_variables)] + fn on_remove(&mut self, id: WidgetId) {} + #[allow(unused_variables)] + fn on_draw(&mut self, active: &ActiveData) {} + #[allow(unused_variables)] + fn on_undraw(&mut self, active: &ActiveData) {} + + fn widgets(&self) -> &Widgets { + &self.ui().widgets + } + fn widgets_mut(&mut self) -> &mut Widgets { + &mut self.ui_mut().widgets + } + fn free(&mut self) { + while let Some(id) = self.widgets_mut().free_next() { + self.on_remove(id); + } + self.ui_mut().textures.free(); + } +} diff --git a/iris/core/src/ui/painter.rs b/iris/core/src/ui/painter.rs new file mode 100644 index 0000000..f7f4939 --- /dev/null +++ b/iris/core/src/ui/painter.rs @@ -0,0 +1,145 @@ +use crate::{ + Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData, + TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId, + render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst}, + util::Vec2, +}; + +/// makes your surfaces look pretty +pub struct Painter<'a> { + pub(super) state: &'a mut UiRenderState, + pub(super) rsc: &'a mut dyn UiRsc, + + pub(super) region: UiRegion, + pub(super) mask: MaskIdx, + pub(super) textures: Vec, + pub(super) primitives: Vec, + pub(super) children: Vec, + pub layer: usize, + pub(super) id: WidgetId, +} + +impl<'a> Painter<'a> { + fn primitive_at(&mut self, primitive: P, region: UiRegion) { + let h = self.state.layers.write( + self.layer, + PrimitiveInst { + id: self.id, + primitive, + region, + mask_idx: self.mask, + }, + ); + if self.mask != MaskIdx::NONE { + // TODO: I have no clue if this works at all :joy: + self.rsc.ui_mut().masks.push_ref(self.mask); + } + self.primitives.push(h); + } + + /// Writes a primitive to be rendered + pub fn primitive(&mut self, primitive: P) { + self.primitive_at(primitive, self.region) + } + + pub fn primitive_within(&mut self, primitive: P, region: UiRegion) { + self.primitive_at(primitive, region.within(&self.region)); + } + + pub fn set_mask(&mut self, region: UiRegion) { + assert!(self.mask == MaskIdx::NONE); + self.mask = self.rsc.ui_mut().masks.push(Mask { region }); + } + + /// Draws a widget within this widget's region. + pub fn widget(&mut self, id: &StrongWidget) { + self.widget_at(id, self.region); + } + + /// Draws a widget somewhere within this one. + /// Useful for drawing child widgets in select areas. + pub fn widget_within(&mut self, id: &StrongWidget, region: UiRegion) { + self.widget_at(id, region.within(&self.region)); + } + + fn widget_at(&mut self, id: &StrongWidget, region: UiRegion) { + self.children.push(id.id()); + self.state.draw_inner( + self.layer, + id.id(), + region, + Some(self.id), + self.mask, + None, + self.rsc, + ); + } + + pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) { + self.textures.push(handle.clone()); + self.primitive_at(handle.primitive(), region.within(&self.region)); + } + + pub fn texture(&mut self, handle: &TextureHandle) { + self.textures.push(handle.clone()); + self.primitive(handle.primitive()); + } + + pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) { + self.textures.push(handle.clone()); + self.primitive_at(handle.primitive(), region); + } + + /// returns (handle, offset from top left) + pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText { + let ui = self.rsc.ui_mut(); + ui.text.draw(buffer, attrs, &mut ui.textures) + } + + pub fn region(&self) -> UiRegion { + self.region + } + + pub fn size(&mut self, id: &StrongWidget) -> Size { + self.size_ctx().size(id) + } + + pub fn len_axis(&mut self, id: &StrongWidget, axis: Axis) -> Len { + match axis { + Axis::X => self.size_ctx().width(id), + Axis::Y => self.size_ctx().height(id), + } + } + + pub fn output_size(&self) -> Vec2 { + self.state.output_size + } + + pub fn px_size(&mut self) -> Vec2 { + self.region.size().to_abs(self.state.output_size) + } + + pub fn text_data(&mut self) -> &mut TextData { + &mut self.rsc.ui_mut().text + } + + pub fn child_layer(&mut self) { + self.layer = self.state.layers.child(self.layer); + } + + pub fn next_layer(&mut self) { + self.layer = self.state.layers.next(self.layer); + } + + pub fn label(&self) -> &str { + &self.rsc.widgets().data(self.id).unwrap().label + } + + pub fn id(&self) -> &WidgetId { + &self.id + } + + pub fn size_ctx(&mut self) -> SizeCtx<'_> { + self.state.size_ctx(self.id, self.region.size(), self.rsc) + } +} diff --git a/iris/core/src/ui/render_state.rs b/iris/core/src/ui/render_state.rs new file mode 100644 index 0000000..57e79a6 --- /dev/null +++ b/iris/core/src/ui/render_state.rs @@ -0,0 +1,319 @@ +use crate::{ + ActiveData, Axis, IdLike, MaskIdx, Painter, PixelRegion, PrimitiveLayers, SizeCtx, + StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets, + ui::cache::Cache, + util::{HashMap, HashSet, Vec2, forget_ref}, +}; + +pub struct UiRenderState { + pub active: HashMap, + pub layers: PrimitiveLayers, + pub(super) output_size: Vec2, + pub cache: Cache, + + old_root: Option, + resized: bool, + draw_started: HashSet, +} + +impl UiRenderState { + pub fn new() -> Self { + Self { + active: Default::default(), + layers: Default::default(), + cache: Default::default(), + output_size: Vec2::ZERO, + old_root: None, + resized: false, + draw_started: Default::default(), + } + } + + pub fn resize(&mut self, size: impl Into) { + self.output_size = size.into(); + self.resized = true; + } + + pub fn update<'a>(&mut self, root: impl Into>, rsc: &mut dyn UiRsc) { + // safety mechanism for memory leaks; might wanna return a result instead so user can + // decide whether to panic or not + if !rsc.widgets().waiting.is_empty() { + let widgets = rsc.widgets(); + let len = widgets.waiting.len(); + let all: Vec<_> = widgets + .waiting + .iter() + .map(|&w| format!("'{}' ({w:?})", widgets.label(w))) + .collect(); + panic!( + "{len} widget(s) were never upgraded\n\ + this is likely a memory leak; consider upgrading to strong if you plan on using it later\n\ + weak widgets: {all:#?}" + ); + } + let root = root.into(); + if self.root_changed(root) || self.resized { + self.redraw_all(root, rsc); + self.old_root = root.map(|r| r.id()); + self.resized = false; + } else if rsc.widgets().has_updates() { + self.redraw_updates(rsc); + } + } + + fn redraw_all(&mut self, root: Option<&StrongWidget>, rsc: &mut dyn UiRsc) { + self.clear(rsc); + // free all resources & cache + if let Some(id) = root { + self.draw_inner(0, id.id(), UiRegion::FULL, None, MaskIdx::NONE, None, rsc); + } + } + + // TODO: should prolly make a DrawInfo struct or smth for everything other than rsc + #[allow(clippy::too_many_arguments)] + pub(super) fn draw_inner( + &mut self, + layer: usize, + id: WidgetId, + region: UiRegion, + parent: Option, + mask: MaskIdx, + old_children: Option>, + rsc: &mut dyn UiRsc, + ) { + let mut old_children = old_children.unwrap_or_default(); + if let Some(active) = self.active.get_mut(&id) + && !rsc.widgets().needs_redraw.contains(&id) + { + // check to see if we can skip drawing first + if active.region == region { + return; + } else if active.region.size() == region.size() { + // TODO: epsilon? + let from = active.region; + self.mov(id, from, region); + return; + } + // if not, then maintain resize and track old children to remove unneeded + let active = self.remove(id, false, rsc).unwrap(); + old_children = active.children; + } + + // draw widget + self.draw_started.insert(id); + + let mut painter = Painter { + state: self, + region, + mask, + layer, + id, + textures: Vec::new(), + primitives: Vec::new(), + children: Vec::new(), + rsc, + }; + + let mut widget = painter.rsc.widgets().get_dyn_dynamic(id); + widget.draw(&mut painter); + drop(widget); + + let Painter { + state: _, + rsc: _, + region, + mask, + textures, + primitives, + children, + layer, + id, + } = painter; + + // add to active + let active = ActiveData { + id, + region, + parent, + textures, + primitives, + children, + mask, + layer, + }; + + // remove old children that weren't kept + for c in &old_children { + if !active.children.contains(c) { + self.remove_rec(*c, rsc); + } + } + + rsc.on_draw(&active); + self.active.insert(id, active); + } + + fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) { + let active = self.active.get_mut(&id).unwrap(); + for h in &active.primitives { + let region = self.layers[h.layer].region_mut(h); + *region = region.outside(&from).within(&to); + } + active.region = active.region.outside(&from).within(&to); + // SAFETY: children cannot be recursive + let children = unsafe { forget_ref(&active.children) }; + for child in children { + self.mov(*child, from, to); + } + } + + /// NOTE: instance textures are cleared and self.textures freed + fn remove(&mut self, id: WidgetId, undraw: bool, rsc: &mut dyn UiRsc) -> Option { + let mut active = self.active.remove(&id); + if let Some(active) = &mut active { + for h in &active.primitives { + let mask = self.layers.free(h); + if mask != MaskIdx::NONE { + rsc.ui_mut().masks.remove(mask); + } + } + active.textures.clear(); + rsc.ui_mut().textures.free(); + if undraw { + rsc.on_undraw(active); + } + } + active + } + + fn remove_rec(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> Option { + self.cache.remove(id); + let inst = self.remove(id, true, rsc); + if let Some(inst) = &inst { + for c in &inst.children { + self.remove_rec(*c, rsc); + } + } + inst + } + + fn clear(&mut self, rsc: &mut dyn UiRsc) { + for (_, active) in self.active.drain() { + rsc.on_undraw(&active); + } + self.cache.clear(); + self.layers.clear(); + rsc.widgets_mut().needs_redraw.clear(); + rsc.free(); + } + + pub fn redraw_updates(&mut self, rsc: &mut dyn UiRsc) { + while let Some(&id) = rsc.widgets().needs_redraw.iter().next() { + self.redraw(id, rsc); + } + rsc.free(); + } + + pub fn root_changed<'a>(&self, root: impl Into>) -> bool { + root.into().map(|r| r.id()) != self.old_root + } + + pub fn needs_redraw<'a>( + &self, + root: impl Into>, + widgets: &Widgets, + ) -> bool { + self.root_changed(root) || widgets.has_updates() + } + + pub fn active_widgets(&self) -> usize { + self.active.len() + } + + pub fn debug(&self, widgets: &Widgets, label: &str) -> impl Iterator { + self.active.iter().filter_map(move |(&id, inst)| { + let l = widgets.label(id); + if l == label { Some(inst) } else { None } + }) + } + + pub fn debug_layers(&self) { + for ((idx, depth), primitives) in self.layers.iter_depth() { + let indent = " ".repeat(depth * 2); + let len = primitives.instances().len(); + print!("{indent}{idx}: {len} primitives"); + if len >= 1 { + print!(" ({})", primitives.instances()[0].binding); + } + println!(); + } + } + + pub fn window_region(&self, id: &impl IdLike) -> Option { + let region = self.active.get(&id.id())?.region; + Some(region.to_px(self.output_size)) + } + + /// redraws a widget that's currently active (drawn) + pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) { + rsc.widgets_mut().needs_redraw.remove(&id); + self.draw_started.remove(&id); + // check if parent depends on the desired size of this, if so then redraw it first + for axis in [Axis::X, Axis::Y] { + if let Some(&(outer, old)) = self.cache.size.axis_dyn(axis).get(&id) + && let Some(current) = self.active.get(&id) + && let Some(pid) = current.parent + { + self.cache.size.axis_dyn(axis).remove(&id); + let new = self.size_ctx(id, outer, rsc).len_axis(id, axis); + self.cache.size.axis_dyn(axis).insert(id, (outer, new)); + if new != old { + self.redraw(pid, rsc); + } + } + } + + if self.draw_started.contains(&id) { + return; + } + + let Some(active) = self.remove(id, false, rsc) else { + return; + }; + + self.draw_inner( + active.layer, + id, + active.region, + active.parent, + active.mask, + Some(active.children), + rsc, + ); + } + + pub(super) fn size_ctx<'b>( + &'b mut self, + source: WidgetId, + outer: UiVec2, + rsc: &'b mut dyn UiRsc, + ) -> SizeCtx<'b> { + let ui = rsc.ui_mut(); + SizeCtx { + source, + cache: &mut self.cache, + text: &mut ui.text, + textures: &mut ui.textures, + widgets: &ui.widgets, + outer, + output_size: self.output_size, + id: source, + } + } +} + +impl Default for UiRenderState { + fn default() -> Self { + Self::new() + } +} diff --git a/iris/core/src/ui/size.rs b/iris/core/src/ui/size.rs new file mode 100644 index 0000000..6f82492 --- /dev/null +++ b/iris/core/src/ui/size.rs @@ -0,0 +1,86 @@ +use crate::{ + Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, Textures, + UiVec2, WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2, +}; + +pub struct SizeCtx<'a> { + pub text: &'a mut TextData, + pub textures: &'a mut Textures, + pub(super) source: WidgetId, + pub(super) widgets: &'a Widgets, + pub(super) cache: &'a mut Cache, + /// TODO: should this be pub? rn used for sized + pub outer: UiVec2, + pub(super) output_size: Vec2, + pub(super) id: WidgetId, +} + +impl SizeCtx<'_> { + pub fn id(&self) -> &WidgetId { + &self.id + } + + pub fn source(&self) -> &WidgetId { + &self.source + } + + pub(super) fn len_inner(&mut self, id: WidgetId) -> Len { + if let Some((_, len)) = self.cache.size.axis::().get(&id) { + return *len; + } + let len = self + .widgets + .get_dyn_dynamic(id) + .desired_len::(&mut SizeCtx { + text: self.text, + textures: self.textures, + source: self.source, + widgets: self.widgets, + cache: self.cache, + outer: self.outer, + output_size: self.output_size, + id, + }); + self.cache.size.axis::().insert(id, (self.outer, len)); + len + } + + pub fn width(&mut self, id: impl IdLike) -> Len { + self.len_inner::(id.id()) + } + + pub fn height(&mut self, id: impl IdLike) -> Len { + self.len_inner::(id.id()) + } + + pub fn len_axis(&mut self, id: impl IdLike, axis: Axis) -> Len { + match axis { + Axis::X => self.width(id), + Axis::Y => self.height(id), + } + } + + pub fn size(&mut self, id: impl IdLike) -> Size { + let id = id.id(); + Size { + x: self.width(id), + y: self.height(id), + } + } + + pub fn px_size(&mut self) -> Vec2 { + self.outer.to_abs(self.output_size) + } + + pub fn output_size(&mut self) -> Vec2 { + self.output_size + } + + pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText { + self.text.draw(buffer, attrs, self.textures) + } + + pub fn label(&self, id: WidgetId) -> &String { + self.widgets.label(id) + } +} diff --git a/iris/core/src/util/arena.rs b/iris/core/src/util/arena.rs new file mode 100644 index 0000000..9ddfd99 --- /dev/null +++ b/iris/core/src/util/arena.rs @@ -0,0 +1,109 @@ +use std::ops::Deref; + +use crate::util::{Id, IdNum, IdTracker}; + +pub struct Arena { + data: Vec, + tracker: IdTracker, +} + +impl Arena { + pub fn new() -> Self { + Self { + data: Vec::new(), + tracker: IdTracker::default(), + } + } + + pub fn push(&mut self, value: T) -> Id { + let id = self.tracker.next(); + let i = id.idx(); + if i == self.data.len() { + self.data.push(value); + } else { + self.data[i] = value; + } + id + } + + pub fn remove(&mut self, id: Id) -> T + where + T: Copy, + { + let i = id.idx(); + self.tracker.free(id); + self.data[i] + } +} + +impl Default for Arena { + fn default() -> Self { + Self::new() + } +} + +pub struct TrackedArena { + inner: Arena, + refs: Vec, + pub changed: bool, +} + +impl TrackedArena { + pub fn new() -> Self { + Self { + inner: Arena::default(), + refs: Vec::new(), + changed: true, + } + } + + pub fn push(&mut self, value: T) -> Id { + self.changed = true; + let id = self.inner.push(value); + let i = id.idx(); + if i == self.refs.len() { + self.refs.push(0); + } + id + } + + pub fn push_ref(&mut self, i: Id) { + self.refs[i.idx()] += 1; + } + + pub fn remove(&mut self, id: Id) -> T + where + T: Copy, + { + let i = id.idx(); + self.refs[i] -= 1; + if self.refs[i] == 0 { + self.changed = true; + self.inner.remove(id) + } else { + self[i] + } + } +} + +impl Default for TrackedArena { + fn default() -> Self { + Self::new() + } +} + +impl Deref for TrackedArena { + type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.inner.data + } +} + +impl Deref for Arena { + type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.data + } +} diff --git a/iris/core/src/util/borrow.rs b/iris/core/src/util/borrow.rs new file mode 100644 index 0000000..bc8e51a --- /dev/null +++ b/iris/core/src/util/borrow.rs @@ -0,0 +1,35 @@ +use std::ops::{Deref, DerefMut}; + +pub struct DynBorrower<'a, T: ?Sized> { + data: &'a mut T, + borrowed: &'a mut bool, +} + +impl<'a, T: ?Sized> DynBorrower<'a, T> { + pub fn new(data: &'a mut T, borrowed: &'a mut bool) -> Self { + if *borrowed { + panic!("tried to mutably borrow the same thing twice"); + } + Self { data, borrowed } + } +} + +impl Drop for DynBorrower<'_, T> { + fn drop(&mut self) { + *self.borrowed = false; + } +} + +impl Deref for DynBorrower<'_, T> { + type Target = T; + + fn deref(&self) -> &Self::Target { + self.data + } +} + +impl DerefMut for DynBorrower<'_, T> { + fn deref_mut(&mut self) -> &mut Self::Target { + self.data + } +} diff --git a/iris/core/src/util/change.rs b/iris/core/src/util/change.rs new file mode 100644 index 0000000..f1a01bd --- /dev/null +++ b/iris/core/src/util/change.rs @@ -0,0 +1,30 @@ +use std::ops::{Deref, DerefMut}; + +pub struct MutDetect { + inner: T, + pub changed: bool, +} + +impl Deref for MutDetect { + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.inner + } +} + +impl DerefMut for MutDetect { + fn deref_mut(&mut self) -> &mut Self::Target { + self.changed = true; + &mut self.inner + } +} + +impl From for MutDetect { + fn from(inner: T) -> Self { + MutDetect { + inner, + changed: true, + } + } +} diff --git a/iris/core/src/util/id.rs b/iris/core/src/util/id.rs new file mode 100644 index 0000000..815d635 --- /dev/null +++ b/iris/core/src/util/id.rs @@ -0,0 +1,87 @@ +#[repr(C)] +#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy, bytemuck::Zeroable)] +pub struct Id(I); + +unsafe impl bytemuck::Pod for Id {} + +pub struct IdTracker { + free: Vec>, + cur: Id, +} + +impl IdTracker { + #[allow(clippy::should_implement_trait)] + pub fn next(&mut self) -> Id { + if let Some(id) = self.free.pop() { + return id; + } + let next = self.cur.next(); + std::mem::replace(&mut self.cur, next) + } + + #[allow(dead_code)] + pub fn free(&mut self, id: Id) { + self.free.push(id); + } +} + +impl Id { + #[allow(dead_code)] + /// for debug purposes; should this be exposed? + /// generally you want to use labels with widgets + pub(crate) fn raw(id: I) -> Self { + Self(id) + } + pub fn idx(&self) -> usize { + self.0.idx() + } + pub fn next(&self) -> Id { + Self(self.0.next()) + } + pub const fn preset(value: I) -> Self { + Self(value) + } +} + +impl Default for IdTracker { + fn default() -> Self { + Self { + free: Vec::new(), + cur: Id(I::first()), + } + } +} + +pub trait IdNum { + fn first() -> Self; + fn next(&self) -> Self; + fn idx(&self) -> usize; +} + +impl IdNum for u64 { + fn first() -> Self { + 0 + } + + fn next(&self) -> Self { + self + 1 + } + + fn idx(&self) -> usize { + *self as usize + } +} + +impl IdNum for u32 { + fn first() -> Self { + 0 + } + + fn next(&self) -> Self { + self + 1 + } + + fn idx(&self) -> usize { + *self as usize + } +} diff --git a/iris/core/src/util/math.rs b/iris/core/src/util/math.rs new file mode 100644 index 0000000..4bcdbce --- /dev/null +++ b/iris/core/src/util/math.rs @@ -0,0 +1,87 @@ +use std::ops::*; + +pub const trait LerpUtil { + fn lerp(self, from: Self, to: Self) -> Self; + fn lerp_inv(self, from: Self, to: Self) -> Self; +} + +pub const trait DivOr { + fn div_or(self, rhs: Self, other: Self) -> Self; +} + +impl const DivOr for f32 { + fn div_or(self, rhs: Self, other: Self) -> Self { + let res = self / rhs; + if res.is_nan() { other } else { res } + } +} + +impl + const Sub + const Mul + const DivOr + Copy> const + LerpUtil for T +{ + /// linear interpolation + /// from * (1.0 - self) + to * self + fn lerp(self, from: Self, to: Self) -> Self { + from + (to - from) * self + } + /// inverse of lerp + fn lerp_inv(self, from: Self, to: Self) -> Self { + (self - from).div_or(to - from, from) + } +} + +macro_rules! impl_op { + ($T:ident $op:ident $fn:ident $opa:ident $fna:ident; $($field:ident)*) => { + #[allow(non_snake_case)] + mod ${concat($T, _op_, $fn, _impl)} { + use super::*; + #[allow(unused_imports)] + use std::ops::*; + impl const $op for $T { + type Output = Self; + + fn $fn(self, rhs: Self) -> Self::Output { + Self { + $($field: self.$field.$fn(rhs.$field),)* + } + } + } + impl const $opa for $T { + fn $fna(&mut self, rhs: Self) { + *self = self.$fn(rhs); + } + } + impl const $op for $T { + type Output = Self; + + fn $fn(self, rhs: f32) -> Self::Output { + Self { + $($field: self.$field.$fn(rhs),)* + } + } + } + impl const $op<$T> for f32 { + type Output = $T; + + fn $fn(self, rhs: $T) -> Self::Output { + $T { + $($field: self.$fn(rhs.$field),)* + } + } + } + impl const $opa for $T { + fn $fna(&mut self, rhs: f32) { + *self = self.$fn(rhs); + } + } + } + }; + ($T:ident $op:ident $fn:ident; $($field:ident)*) => { + impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*); + }; + (impl $op:ident for $T:ident: $fn:ident $($field:ident)*) => { + impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*); + }; +} + +pub(crate) use impl_op; diff --git a/iris/core/src/util/mod.rs b/iris/core/src/util/mod.rs new file mode 100644 index 0000000..69c3331 --- /dev/null +++ b/iris/core/src/util/mod.rs @@ -0,0 +1,24 @@ +mod arena; +mod borrow; +mod change; +mod id; +mod math; +mod refcount; +mod slot; +mod trust; +mod typemap; +mod vec2; + +pub use arena::*; +pub use borrow::*; +pub use change::*; +pub use id::*; +pub use math::*; +pub use refcount::*; +pub use slot::*; +pub use trust::*; +pub use typemap::*; +pub use vec2::*; + +pub type HashMap = fxhash::FxHashMap; +pub type HashSet = fxhash::FxHashSet; diff --git a/iris/core/src/util/refcount.rs b/iris/core/src/util/refcount.rs new file mode 100644 index 0000000..77c1660 --- /dev/null +++ b/iris/core/src/util/refcount.rs @@ -0,0 +1,36 @@ +use std::sync::{ + Arc, + atomic::{AtomicU32, Ordering}, +}; + +#[derive(Debug)] +pub struct RefCounter(Arc); + +impl RefCounter { + pub fn new() -> Self { + Self(Arc::new(0.into())) + } + pub fn refs(&self) -> u32 { + self.0.load(Ordering::Acquire) + } + pub fn drop(&mut self) -> bool { + let refs = self.0.fetch_sub(1, Ordering::Release); + refs == 0 + } + pub fn quiet_clone(&self) -> Self { + Self(self.0.clone()) + } +} + +impl Default for RefCounter { + fn default() -> Self { + Self::new() + } +} + +impl Clone for RefCounter { + fn clone(&self) -> Self { + self.0.fetch_add(1, Ordering::Release); + Self(self.0.clone()) + } +} diff --git a/iris/core/src/util/slot.rs b/iris/core/src/util/slot.rs new file mode 100644 index 0000000..94fd2a1 --- /dev/null +++ b/iris/core/src/util/slot.rs @@ -0,0 +1,69 @@ +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct SlotId { + idx: u32, + genr: u32, +} + +pub struct SlotVec { + data: Vec<(u32, Option)>, + free: Vec, +} + +impl SlotVec { + pub fn new() -> Self { + Self { + data: Default::default(), + free: Default::default(), + } + } + + pub fn add(&mut self, x: T) -> SlotId { + if let Some(idx) = self.free.pop() { + let (genr, data) = &mut self.data[idx as usize]; + *data = Some(x); + SlotId { idx, genr: *genr } + } else { + let idx = self.data.len() as u32; + let genr = 0; + self.data.push((genr, Some(x))); + SlotId { idx, genr } + } + } + + pub fn free(&mut self, id: SlotId) { + let (genr, data) = &mut self.data[id.idx as usize]; + *genr += 1; + *data = None; + self.free.push(id.idx); + } + + pub fn get(&self, id: SlotId) -> Option<&T> { + let slot = &self.data[id.idx as usize]; + if slot.0 != id.genr { + return None; + } + slot.1.as_ref() + } + + pub fn get_mut(&mut self, id: SlotId) -> Option<&mut T> { + let slot = &mut self.data[id.idx as usize]; + if slot.0 != id.genr { + return None; + } + slot.1.as_mut() + } + + pub fn len(&self) -> usize { + self.data.len() - self.free.len() + } + + pub fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +impl Default for SlotVec { + fn default() -> Self { + Self::new() + } +} diff --git a/iris/core/src/util/trust.rs b/iris/core/src/util/trust.rs new file mode 100644 index 0000000..b9d1a6b --- /dev/null +++ b/iris/core/src/util/trust.rs @@ -0,0 +1,17 @@ +#[allow(clippy::missing_safety_doc)] +pub unsafe fn forget_ref<'a, T>(x: &T) -> &'a T { + unsafe { std::mem::transmute::<&T, &T>(x) } +} + +#[allow(clippy::missing_safety_doc)] +pub unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T { + unsafe { std::mem::transmute::<&mut T, &mut T>(x) } +} + +#[allow(clippy::mut_from_ref, clippy::missing_safety_doc)] +pub unsafe fn to_mut(x: &T) -> &mut T { + #[allow(mutable_transmutes)] + unsafe { + std::mem::transmute::<&T, &mut T>(x) + } +} diff --git a/iris/core/src/util/typemap.rs b/iris/core/src/util/typemap.rs new file mode 100644 index 0000000..3a24e8b --- /dev/null +++ b/iris/core/src/util/typemap.rs @@ -0,0 +1,56 @@ +use crate::util::HashMap; +use std::{ + any::TypeId, + marker::Unsize, + ops::{Deref, DerefMut}, +}; + +pub struct TypeMap { + map: HashMap>, +} + +impl TypeMap { + pub fn set_type + 'static>(&mut self, val: T) { + self.map + .insert(TypeId::of::(), Box::new(val) as Box); + } + + pub fn type_mut + 'static>(&mut self) -> Option<&mut T> { + Some(Self::convert_mut(self.map.get_mut(&TypeId::of::())?)) + } + + pub fn type_or_default + 'static>(&mut self) -> &mut T { + Self::convert_mut( + self.map + .entry(TypeId::of::()) + .or_insert(Box::new(T::default()) as Box), + ) + } + + fn convert_mut>(entry: &mut Box) -> &mut T { + // allegedly this is just what Any does... + unsafe { &mut *(entry.as_mut() as *mut Trait as *mut T) } + } +} + +impl Deref for TypeMap { + type Target = HashMap>; + + fn deref(&self) -> &Self::Target { + &self.map + } +} + +impl DerefMut for TypeMap { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.map + } +} + +impl Default for TypeMap { + fn default() -> Self { + Self { + map: Default::default(), + } + } +} diff --git a/iris/core/src/util/vec2.rs b/iris/core/src/util/vec2.rs new file mode 100644 index 0000000..7609861 --- /dev/null +++ b/iris/core/src/util/vec2.rs @@ -0,0 +1,99 @@ +use crate::util::{DivOr, impl_op}; +use std::{hash::Hash, ops::*}; + +#[repr(C)] +#[derive(Clone, Copy, PartialEq, Default, bytemuck::Pod, bytemuck::Zeroable)] +pub struct Vec2 { + pub x: f32, + pub y: f32, +} + +impl Eq for Vec2 {} + +impl Hash for Vec2 { + fn hash(&self, state: &mut H) { + state.write_u32(self.x.to_bits()); + state.write_u32(self.y.to_bits()); + } +} + +impl Vec2 { + pub const ZERO: Self = Self::new(0.0, 0.0); + pub const ONE: Self = Self::new(1.0, 1.0); + + pub const fn new(x: f32, y: f32) -> Self { + Self { x, y } + } + + pub const fn round(self) -> Self { + Self { + x: self.x.round(), + y: self.y.round(), + } + } + + pub const fn floor(self) -> Self { + Self { + x: self.x.floor(), + y: self.y.floor(), + } + } + + pub const fn ceil(self) -> Self { + Self { + x: self.x.ceil(), + y: self.y.ceil(), + } + } + + pub const fn tuple(&self) -> (f32, f32) { + (self.x, self.y) + } + + pub const fn with_x(mut self, x: f32) -> Self { + self.x = x; + self + } + + pub const fn with_y(mut self, y: f32) -> Self { + self.y = y; + self + } +} + +// this version looks kinda cool... is it more readable? more annoying to copy and change though +impl_op!(impl Add for Vec2: add x y); +impl_op!(Vec2 Sub sub; x y); +impl_op!(Vec2 Mul mul; x y); +impl_op!(Vec2 Div div; x y); + +impl const DivOr for Vec2 { + fn div_or(self, rhs: Self, other: Self) -> Self { + Self { + x: self.x.div_or(rhs.x, other.x), + y: self.y.div_or(rhs.y, other.y), + } + } +} + +impl Neg for Vec2 { + type Output = Self; + + fn neg(mut self) -> Self::Output { + self.x = -self.x; + self.y = -self.y; + self + } +} + +impl std::fmt::Debug for Vec2 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({}, {})", self.x, self.y) + } +} + +impl std::fmt::Display for Vec2 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({}, {})", self.x, self.y) + } +} diff --git a/iris/core/src/widget/data.rs b/iris/core/src/widget/data.rs new file mode 100644 index 0000000..8d693e7 --- /dev/null +++ b/iris/core/src/widget/data.rs @@ -0,0 +1,22 @@ +use crate::Widget; + +pub struct WidgetData { + pub widget: Box, + pub label: String, + /// dynamic borrow checking + pub borrowed: bool, +} + +impl WidgetData { + pub fn new(widget: W) -> Self { + let mut label = std::any::type_name::().to_string(); + if let (Some(first), Some(last)) = (label.find(":"), label.rfind(":")) { + label = label.split_at(first).0.to_string() + "::" + label.split_at(last + 1).1; + } + Self { + widget: Box::new(widget), + label, + borrowed: false, + } + } +} diff --git a/iris/core/src/widget/handle.rs b/iris/core/src/widget/handle.rs new file mode 100644 index 0000000..7b52275 --- /dev/null +++ b/iris/core/src/widget/handle.rs @@ -0,0 +1,164 @@ +use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender}; + +use crate::{ + UiRsc, Widget, + util::{RefCounter, SlotId}, +}; + +pub type WidgetId = SlotId; + +/// An identifier for a widget that can index a UI or event ctx to get it. +/// This is a strong handle that does not impl Clone, and when it is dropped, +/// a signal is sent to the owning UI to clean up the resources. +/// +/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs? +pub struct StrongWidget { + pub(super) id: WidgetId, + counter: RefCounter, + send: Sender, + ty: *const W, +} + +/// A weak handle to a widget. +/// Will not keep it alive, but can still be used for indexing like WidgetHandle. +pub struct WeakWidget { + pub(super) id: WidgetId, + #[allow(unused)] + ty: *const W, +} + +impl> StrongWidget { + pub fn any(self) -> StrongWidget { + self + } +} + +impl StrongWidget { + pub(crate) fn new(id: WidgetId, send: Sender) -> Self { + Self { + id, + counter: RefCounter::new(), + send, + ty: null_ptr(), + } + } + + pub fn id(&self) -> WidgetId { + self.id + } + + pub fn refs(&self) -> u32 { + self.counter.refs() + } + + pub fn weak(&self) -> WeakWidget { + let Self { ty, id, .. } = *self; + WeakWidget { ty, id } + } +} + +impl WeakWidget { + pub(crate) fn new(id: WidgetId) -> Self { + Self { id, ty: null_ptr() } + } + + pub fn id(&self) -> WidgetId { + self.id + } + + #[track_caller] + pub fn upgrade(self, ui: &mut impl UiRsc) -> StrongWidget { + ui.widgets_mut().upgrade(self) + } +} + +impl Drop for StrongWidget { + fn drop(&mut self) { + if self.counter.drop() { + let _ = self.send.send(self.id); + } + } +} + +pub trait WidgetIdFn: FnOnce(&mut Rsc) -> WeakWidget {} +impl WeakWidget> WidgetIdFn for F {} + +pub trait IdLike { + type Widget: ?Sized; + fn id(&self) -> WidgetId; +} + +impl IdLike for &StrongWidget { + type Widget = W; + fn id(&self) -> WidgetId { + self.id + } +} + +impl IdLike for StrongWidget { + type Widget = W; + fn id(&self) -> WidgetId { + self.id + } +} + +impl IdLike for WeakWidget { + type Widget = W; + fn id(&self) -> WidgetId { + self.id + } +} + +impl IdLike for WidgetId { + type Widget = dyn Widget; + fn id(&self) -> WidgetId { + *self + } +} + +impl, U: ?Sized> CoerceUnsized> for StrongWidget {} +impl, U: ?Sized> CoerceUnsized> for WeakWidget {} + +impl Clone for WeakWidget { + fn clone(&self) -> Self { + *self + } +} +impl Copy for WeakWidget {} +impl PartialEq for WeakWidget { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl PartialEq for StrongWidget { + fn eq(&self, other: &Self) -> bool { + self.id == other.id + } +} + +impl std::fmt::Debug for StrongWidget { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.id.fmt(f) + } +} + +impl<'a, W: Widget + 'a, State: UiRsc> FnOnce<(&'a mut State,)> for WeakWidget { + type Output = &'a mut W; + + extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output { + &mut args.0.widgets_mut()[self] + } +} + +fn null_ptr() -> *const W { + if size_of::<&W>() == size_of::<*const dyn Widget>() { + let w: *const dyn Widget = &(); + unsafe { std::mem::transmute_copy(&w) } + } else { + unsafe { std::mem::transmute_copy(&[0usize; 1]) } + } +} + +unsafe impl Send for WeakWidget {} +unsafe impl Sync for WeakWidget {} diff --git a/iris/core/src/widget/like.rs b/iris/core/src/widget/like.rs new file mode 100644 index 0000000..45512ae --- /dev/null +++ b/iris/core/src/widget/like.rs @@ -0,0 +1,75 @@ +use crate::UiRsc; + +use super::*; +use std::marker::Unsize; + +pub trait WidgetLike: Sized { + type Widget: Widget + ?Sized + Unsize; + + fn add(self, rsc: &mut Rsc) -> WeakWidget; + + fn add_strong(self, rsc: &mut Rsc) -> StrongWidget { + self.add(rsc).upgrade(rsc) + } + + fn with_id( + self, + f: impl FnOnce(&mut Rsc, WeakWidget) -> WeakWidget, + ) -> impl WidgetIdFn { + move |state| { + let id = self.add(state); + f(state, id) + } + } + + fn set_root(self, rsc: &mut Rsc, root: &mut impl HasRoot) { + let id = self.add_strong(rsc); + root.set_root(id); + } +} + +pub trait HasRoot { + fn set_root(&mut self, root: StrongWidget); +} + +pub trait WidgetArrLike { + #[track_caller] + fn add(self, state: &mut Rsc) -> WidgetArr; +} + +impl WidgetArrLike for WidgetArr { + fn add(self, _: &mut Rsc) -> WidgetArr { + self + } +} + +// variadic generics please save us +macro_rules! impl_widget_arr { + ($n:expr;$($W:ident)*) => { + impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*); + }; + ($n:expr;$($W:ident)*;$($Tag:ident)*) => { + impl,$Tag,)*> WidgetArrLike for ($($W,)*) { + fn add(self, rsc: &mut Rsc) -> WidgetArr<$n> { + #[allow(non_snake_case)] + let ($($W,)*) = self; + WidgetArr::new( + [$($W.add(rsc).upgrade(rsc),)*], + ) + } + } + }; +} + +impl_widget_arr!(1;A); +impl_widget_arr!(2;A B); +impl_widget_arr!(3;A B C); +impl_widget_arr!(4;A B C D); +impl_widget_arr!(5;A B C D E); +impl_widget_arr!(6;A B C D E F); +impl_widget_arr!(7;A B C D E F G); +impl_widget_arr!(8;A B C D E F G H); +impl_widget_arr!(9;A B C D E F G H I); +impl_widget_arr!(10;A B C D E F G H I J); +impl_widget_arr!(11;A B C D E F G H I J K); +impl_widget_arr!(12;A B C D E F G H I J K L); diff --git a/iris/core/src/widget/mod.rs b/iris/core/src/widget/mod.rs new file mode 100644 index 0000000..a0f084c --- /dev/null +++ b/iris/core/src/widget/mod.rs @@ -0,0 +1,87 @@ +use crate::{Axis, AxisT, Len, Painter, SizeCtx}; +use std::any::Any; + +mod data; +mod handle; +mod like; +mod tag; +mod view; +mod widgets; + +pub use data::*; +pub use handle::*; +pub use like::*; +pub use tag::*; +pub use view::*; +pub use widgets::*; + +pub trait Widget: Any { + fn draw(&mut self, painter: &mut Painter); + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len; + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len; +} + +pub trait WidgetAxisFns { + fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len; +} + +impl WidgetAxisFns for W { + fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len { + match A::get() { + Axis::X => self.desired_width(ctx), + Axis::Y => self.desired_height(ctx), + } + } +} + +impl Widget for () { + fn draw(&mut self, _: &mut Painter) {} + fn desired_width(&mut self, _: &mut SizeCtx) -> Len { + Len::ZERO + } + fn desired_height(&mut self, _: &mut SizeCtx) -> Len { + Len::ZERO + } +} + +impl dyn Widget { + pub fn as_any(&self) -> &dyn Any { + self + } + + pub fn as_any_mut(&mut self) -> &mut dyn Any { + self + } +} + +/// A function that returns a widget given a UI. +/// Useful for defining trait functions on widgets that create a parent widget so that the children +/// don't need to be IDs yet +pub trait WidgetFn: FnOnce(&mut State) -> W {} +impl W> WidgetFn for F {} + +pub struct WidgetArr { + pub arr: [StrongWidget; LEN], +} + +impl WidgetArr { + pub fn new(arr: [StrongWidget; LEN]) -> Self { + Self { arr } + } +} + +pub trait WidgetOption { + fn get(self, state: &mut State) -> Option; +} + +impl WidgetOption for () { + fn get(self, _: &mut State) -> Option { + None + } +} + +impl Option> WidgetOption for F { + fn get(self, state: &mut State) -> Option { + self(state) + } +} diff --git a/iris/core/src/widget/tag.rs b/iris/core/src/widget/tag.rs new file mode 100644 index 0000000..1356dac --- /dev/null +++ b/iris/core/src/widget/tag.rs @@ -0,0 +1,64 @@ +use super::*; +use crate::UiRsc; +use std::marker::Unsize; + +pub struct WidgetTag; +impl WidgetLike for W { + type Widget = W; + fn add(self, rsc: &mut Rsc) -> WeakWidget { + let w = rsc.ui_mut().widgets.add_weak(self); + rsc.on_add(w); + w + } +} + +pub struct FnTag; +impl W> WidgetLike for F { + type Widget = W; + fn add(self, rsc: &mut Rsc) -> WeakWidget { + self(rsc).add(rsc) + } +} + +pub trait WidgetFnTrait { + type Widget: Widget; + fn run(self, rsc: &mut Rsc) -> Self::Widget; +} +pub struct FnTraitTag; +impl> WidgetLike for T { + type Widget = T::Widget; + #[track_caller] + fn add(self, rsc: &mut Rsc) -> WeakWidget { + self.run(rsc).add(rsc) + } +} + +pub struct RefTag; +impl> WidgetLike + for WeakWidget +{ + type Widget = W; + fn add(self, _: &mut Rsc) -> WeakWidget { + self + } +} + +pub struct RefFnTag; +impl, F: FnOnce(&mut Rsc) -> WeakWidget> + WidgetLike for F +{ + type Widget = W; + fn add(self, rsc: &mut Rsc) -> WeakWidget { + self(rsc) + } +} + +pub struct ViewTag; +impl WidgetLike for V { + type Widget = V::Widget; + fn add(self, _: &mut Rsc) -> WeakWidget { + self.root() + } +} + +pub struct ArrTag; diff --git a/iris/core/src/widget/view.rs b/iris/core/src/widget/view.rs new file mode 100644 index 0000000..19c7eea --- /dev/null +++ b/iris/core/src/widget/view.rs @@ -0,0 +1,24 @@ +use std::marker::Unsize; + +use crate::{IdLike, WeakWidget, Widget}; + +pub trait WidgetView { + type Widget: Widget + ?Sized + Unsize; + fn root(&self) -> WeakWidget; +} + +pub trait HasWidget { + type Widget: Widget + ?Sized + Unsize; +} + +impl + ?Sized> HasWidget for WeakWidget { + type Widget = W; +} + +impl IdLike for WV { + type Widget = WV::Widget; + + fn id(&self) -> super::WidgetId { + self.root().id + } +} diff --git a/iris/core/src/widget/widgets.rs b/iris/core/src/widget/widgets.rs new file mode 100644 index 0000000..6098aa6 --- /dev/null +++ b/iris/core/src/widget/widgets.rs @@ -0,0 +1,145 @@ +use std::sync::mpsc::{Receiver, Sender, channel}; + +use crate::{ + IdLike, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId, + util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut}, +}; + +pub struct Widgets { + pub needs_redraw: HashSet, + vec: SlotVec, + send: Sender, + recv: Receiver, + pub(crate) waiting: HashSet, +} + +impl Widgets { + pub fn new() -> Self { + let (send, recv) = channel(); + Self { + needs_redraw: Default::default(), + vec: Default::default(), + waiting: Default::default(), + send, + recv, + } + } + + pub fn has_updates(&self) -> bool { + !self.needs_redraw.is_empty() + } + + pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> { + Some(self.vec.get(id)?.widget.as_ref()) + } + + pub fn get_dyn_mut(&mut self, id: WidgetId) -> Option<&mut dyn Widget> { + self.needs_redraw.insert(id); + Some(self.vec.get_mut(id)?.widget.as_mut()) + } + + /// get_dyn but dynamic borrow checking of widgets + /// lets you do recursive (tree) operations, like the painter does + pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> { + // SAFETY: must guarantee no other mutable references to this widget exist + // done through the borrow variable + let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) }; + if data.borrowed { + panic!("tried to mutably borrow the same widget twice"); + } + WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed) + } + + pub fn get(&self, id: &I) -> Option<&I::Widget> + where + I::Widget: Sized + Widget, + { + self.get_dyn(id.id())?.as_any().downcast_ref() + } + + pub fn get_mut(&mut self, id: &I) -> Option<&mut I::Widget> + where + I::Widget: Sized + Widget, + { + self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut() + } + + pub fn add_strong(&mut self, widget: W) -> StrongWidget { + let id = self.vec.add(WidgetData::new(widget)); + StrongWidget::new(id, self.send.clone()) + } + + pub fn add_weak(&mut self, widget: W) -> WeakWidget { + let id = self.vec.add(WidgetData::new(widget)); + self.waiting.insert(id); + WeakWidget::new(id) + } + + #[track_caller] + pub fn upgrade(&mut self, rf: WeakWidget) -> StrongWidget { + if !self.waiting.remove(&rf.id()) { + let label = self.label(rf); + let id = rf.id(); + panic!( + "widget '{label}' ({id:?}) was already added\ncannot add a widget twice; consider creating two" + ) + } + StrongWidget::new(rf.id(), self.send.clone()) + } + + pub fn data(&self, id: impl IdLike) -> Option<&WidgetData> { + self.vec.get(id.id()) + } + + pub fn label(&self, id: impl IdLike) -> &String { + &self.data(id.id()).unwrap().label + } + + /// useful for debugging + pub fn set_label(&mut self, id: impl IdLike, label: String) { + self.data_mut(id.id()).unwrap().label = label; + } + + pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> { + self.vec.get_mut(id.id()) + } + + pub fn free_next(&mut self) -> Option { + let next = self.recv.try_recv().ok()?; + self.vec.free(next); + Some(next) + } + + #[allow(clippy::len_without_is_empty)] + pub fn len(&self) -> usize { + self.vec.len() + } +} + +impl Default for Widgets { + fn default() -> Self { + Self::new() + } +} + +pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>; + +impl std::ops::Index for Widgets +where + I::Widget: Sized + Widget, +{ + type Output = I::Widget; + + fn index(&self, id: I) -> &Self::Output { + self.get(&id).unwrap() + } +} + +impl std::ops::IndexMut for Widgets +where + I::Widget: Sized + Widget, +{ + fn index_mut(&mut self, id: I) -> &mut Self::Output { + self.get_mut(&id).unwrap() + } +} diff --git a/iris/examples/minimal.rs b/iris/examples/minimal.rs new file mode 100644 index 0000000..e98ae5b --- /dev/null +++ b/iris/examples/minimal.rs @@ -0,0 +1,21 @@ +use iris::prelude::*; + +fn main() { + DefaultApp::::run(); +} + +#[derive(DefaultUiState)] +struct State { + ui_state: DefaultUiState, +} + +impl DefaultAppState for State { + fn new( + mut ui_state: DefaultUiState, + rsc: &mut DefaultRsc, + _: Proxy, + ) -> Self { + rect(Color::RED).set_root(rsc, &mut ui_state); + Self { ui_state } + } +} diff --git a/iris/examples/tabs/assets/sungals.png b/iris/examples/tabs/assets/sungals.png new file mode 100755 index 0000000000000000000000000000000000000000..0070de2fb0307d392a63d60564e8205b55d51896 GIT binary patch literal 8911 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 literal 0 HcmV?d00001 diff --git a/iris/examples/tabs/main.rs b/iris/examples/tabs/main.rs new file mode 100644 index 0000000..d9789f1 --- /dev/null +++ b/iris/examples/tabs/main.rs @@ -0,0 +1,225 @@ +use cosmic_text::Family; +use std::{cell::RefCell, rc::Rc}; +use winit::event::WindowEvent; + +use iris::prelude::*; +type ClientRsc = DefaultRsc; + +fn main() { + DefaultApp::::run(); +} + +#[derive(DefaultUiState)] +pub struct Client { + ui_state: DefaultUiState, + info: WeakWidget, +} + +impl DefaultAppState for Client { + fn new( + mut ui_state: DefaultUiState, + rsc: &mut DefaultRsc, + _: Proxy, + ) -> Self { + let rrect = rect(Color::WHITE).radius(20); + let pad_test = ( + rrect.color(Color::BLUE), + ( + rrect + .color(Color::RED) + .sized((100, 100)) + .center() + .width(rest(2)), + ( + rrect.color(Color::ORANGE), + rrect.color(Color::LIME).pad(10.0), + ) + .span(Dir::RIGHT) + .width(rest(2)), + rrect.color(Color::YELLOW), + ) + .span(Dir::RIGHT) + .pad(10) + .width(rest(3)), + ) + .span(Dir::RIGHT) + .add(rsc); + + let span_test = ( + rrect.color(Color::GREEN).width(100), + rrect.color(Color::ORANGE), + rrect.color(Color::CYAN), + rrect.color(Color::BLUE).width(rel(0.5)), + rrect.color(Color::MAGENTA).width(100), + rrect.color(Color::RED).width(100), + ) + .span(Dir::LEFT) + .add(rsc); + + let span_add = Span::empty(Dir::RIGHT).add(rsc); + + let add_button = rect(Color::LIME) + .radius(30) + .on(CursorSense::click(), move |_, rsc| { + let child = image(include_bytes!("assets/sungals.png")) + .center() + .add_strong(rsc); + span_add(rsc).push(child); + }) + .sized((150, 150)) + .align(Align::BOT_RIGHT); + + let del_button = rect(Color::RED) + .radius(30) + .on(CursorSense::click(), move |_, rsc| { + span_add(rsc).pop(); + }) + .sized((150, 150)) + .align(Align::BOT_LEFT); + + let span_add_test = (span_add, add_button, del_button).stack().add(rsc); + + let btext = |content| wtext(content).size(30); + + let text_test = ( + btext("this is a").align(Align::LEFT), + btext("teeeeeeeest").align(Align::RIGHT), + btext("okkk\nokkkkkk!").align(Align::LEFT), + btext("hmm"), + btext("a"), + ( + btext("'").family(Family::Monospace).align(Align::TOP), + btext("'").family(Family::Monospace), + btext(":gamer mode").family(Family::Monospace), + rect(Color::CYAN).sized((10, 10)).center(), + rect(Color::RED).sized((100, 100)).center(), + rect(Color::PURPLE).sized((50, 50)).align(Align::TOP), + ) + .span(Dir::RIGHT) + .center(), + wtext("pretty cool right?").size(50), + ) + .span(Dir::DOWN) + .add(rsc); + + let texts = Span::empty(Dir::DOWN).gap(10).add(rsc); + let msg_area = texts.scrollable().masked().background(rect(Color::SKY)); + let add_text = wtext("add") + .editable(EditMode::MultiLine) + .text_align(Align::LEFT) + .size(30) + .attr::(()) + .on(Submit, move |ctx, rsc| { + let w = ctx.widget; + let content = w.edit(rsc).take(); + let text = wtext(content) + .editable(EditMode::MultiLine) + .size(30) + .text_align(Align::LEFT) + .wrap(true) + .attr::(()); + let msg_box = text + .background(rect(Color::WHITE.darker(0.5))) + .add_strong(rsc); + texts(rsc).push(msg_box); + }) + .add(rsc); + + let text_edit_scroll = ( + msg_area.height(rest(1)), + ( + Rect::new(Color::WHITE.darker(0.9)), + ( + add_text.width(rest(1)), + Rect::new(Color::GREEN) + .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| { + rsc.run_event::(add_text, (), ctx.state); + }) + .sized((40, 40)), + ) + .span(Dir::RIGHT) + .pad(10), + ) + .stack() + .size(StackSize::Child(1)) + .layer_offset(1) + .align(Align::BOT), + ) + .span(Dir::DOWN) + .add(rsc); + + let main = WidgetPtr::new().add(rsc); + + let vals = Rc::new(RefCell::new((0, Vec::new()))); + let mut switch_button = |color, to: WeakWidget, label| { + let to = to.upgrade(rsc); + let vec = &mut vals.borrow_mut().1; + let i = vec.len(); + if vec.is_empty() { + vec.push(None); + main(rsc).set(to); + } else { + vec.push(Some(to)); + } + let vals = vals.clone(); + let rect = rect(color) + .on(CursorSense::click(), move |ctx, rsc| { + let (prev, vec) = &mut *vals.borrow_mut(); + if let Some(h) = vec[i].take() { + vec[*prev] = main(rsc).replace(h); + *prev = i; + } + ctx.widget(rsc).color = color.darker(0.3); + }) + .on( + CursorSense::HoverStart | CursorSense::unclick(), + move |ctx, rsc| { + ctx.widget(rsc).color = color.brighter(0.2); + }, + ) + .on(CursorSense::HoverEnd, move |ctx, rsc| { + ctx.widget(rsc).color = color; + }); + (rect, wtext(label).size(30).text_align(Align::CENTER)).stack() + }; + + let tabs = ( + switch_button(Color::RED, pad_test, "pad"), + switch_button(Color::GREEN, span_test, "span"), + switch_button(Color::BLUE, span_add_test, "image span"), + switch_button(Color::MAGENTA, text_test, "text layout"), + switch_button( + Color::YELLOW.mul_rgb(0.5), + text_edit_scroll, + "text edit scroll", + ), + ) + .span(Dir::RIGHT); + + let info = wtext("").add(rsc); + let info_sect = info.pad(10).align(Align::RIGHT); + + ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect) + .stack() + .set_root(rsc, &mut ui_state); + + Self { ui_state, info } + } + + fn window_event( + &mut self, + _: WindowEvent, + rsc: &mut DefaultRsc, + render: &mut UiRenderState, + ) { + let new = format!( + "widgets: {}\nactive: {}\nviews: {}", + rsc.widgets().len(), + render.active_widgets(), + self.ui_state.renderer.ui.view_count(), + ); + if new != *rsc.widgets()[self.info].content { + *rsc.widgets_mut()[self.info].content = new; + } + } +} diff --git a/iris/examples/task.rs b/iris/examples/task.rs new file mode 100644 index 0000000..63e4d43 --- /dev/null +++ b/iris/examples/task.rs @@ -0,0 +1,34 @@ +use iris::prelude::*; +use std::time::Duration; + +fn main() { + DefaultApp::::run(); +} + +#[derive(DefaultUiState)] +struct State { + ui_state: DefaultUiState, +} + +impl DefaultAppState for State { + fn new( + mut ui_state: DefaultUiState, + rsc: &mut DefaultRsc, + _: Proxy, + ) -> Self { + let rect = rect(Color::RED).add(rsc); + rect.task_on(CursorSense::click(), async move |mut ctx| { + tokio::time::sleep(Duration::from_secs(1)).await; + ctx.update(move |_, rsc| { + let rect = rect(rsc); + if rect.color == Color::RED { + rect.color = Color::BLUE; + } else { + rect.color = Color::RED; + } + }); + }) + .set_root(rsc, &mut ui_state); + Self { ui_state } + } +} diff --git a/iris/examples/view.rs b/iris/examples/view.rs new file mode 100644 index 0000000..b8e06cf --- /dev/null +++ b/iris/examples/view.rs @@ -0,0 +1,53 @@ +use iris::prelude::*; + +fn main() { + DefaultApp::::run(); +} + +#[derive(DefaultUiState)] +struct State { + ui_state: DefaultUiState, +} + +type Rsc = DefaultRsc; + +#[derive(Clone, Copy, WidgetView)] +struct Test { + #[root] + root: WeakWidget, + cur: WeakState, +} + +impl Test { + pub fn new(rsc: &mut Rsc) -> Self { + let root = rect(Color::RED).add(rsc); + let cur = rsc.create_state(root, false); + Self { root, cur } + } + pub fn toggle(&self, rsc: &mut Rsc) { + let cur = &mut rsc[self.cur]; + *cur = !*cur; + if *cur { + rsc[self.root].color = Color::BLUE; + } else { + rsc[self.root].color = Color::RED; + } + } +} + +impl DefaultAppState for State { + fn new( + mut ui_state: DefaultUiState, + rsc: &mut DefaultRsc, + _: Proxy, + ) -> Self { + let test = Test::new(rsc); + + test.on(CursorSense::click(), move |_, rsc| { + test.toggle(rsc); + }) + .set_root(rsc, &mut ui_state); + + Self { ui_state } + } +} diff --git a/iris/macro/Cargo.toml b/iris/macro/Cargo.toml new file mode 100644 index 0000000..42d8dab --- /dev/null +++ b/iris/macro/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "iris-macro" +version.workspace = true +edition.workspace = true + +[dependencies] +proc-macro2 = "1.0.103" +quote = "1.0.42" +syn = { version = "2.0.111", features = ["full"] } + +[lib] +proc-macro = true diff --git a/iris/macro/src/lib.rs b/iris/macro/src/lib.rs new file mode 100644 index 0000000..98b13cf --- /dev/null +++ b/iris/macro/src/lib.rs @@ -0,0 +1,196 @@ +extern crate proc_macro; +use proc_macro::TokenStream; +use quote::quote; +use syn::{ + Attribute, Block, Error, GenericParam, Generics, Ident, ItemStruct, ItemTrait, Signature, + Token, Type, Visibility, + parse::{Parse, ParseStream, Result}, + parse_macro_input, parse_quote, + spanned::Spanned, +}; + +struct Input { + attrs: Vec, + vis: Visibility, + name: Ident, + generics: Generics, + fns: Vec, +} + +struct InputFn { + sig: Signature, + body: Block, +} + +impl Parse for Input { + fn parse(input: ParseStream) -> Result { + let attrs = input.call(Attribute::parse_outer)?; + let vis = input.parse()?; + input.parse::()?; + let name = input.parse()?; + let generics = input.parse::()?; + input.parse::()?; + let mut fns = Vec::new(); + while !input.is_empty() { + let sig = input.parse()?; + let body = input.parse()?; + fns.push(InputFn { sig, body }) + } + if !input.is_empty() { + input.error("function expected"); + } + Ok(Input { + attrs, + vis, + name, + generics, + fns, + }) + } +} + +#[proc_macro] +pub fn widget_trait(input: TokenStream) -> TokenStream { + let Input { + attrs, + vis, + name, + mut generics, + fns, + } = parse_macro_input!(input as Input); + + let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect(); + let impls: Vec<_> = fns + .iter() + .map(|InputFn { sig, body }| quote! { #sig #body }) + .collect(); + + let Some(GenericParam::Type(state)) = generics.params.first() else { + return Error::new(name.span(), "expected state generic parameter") + .into_compile_error() + .into(); + }; + + let state = &state.ident; + + generics + .params + .push(parse_quote!(WL: WidgetLike<#state, Tag>)); + generics.params.push(parse_quote!(Tag)); + + let mut trai: ItemTrait = parse_quote!( + #vis trait #name #generics { + #(#sigs;)* + } + ); + + trai.attrs = attrs; + + quote! { + #trai + + impl #generics #name for WL { + #(#impls)* + } + } + .into() +} + +#[proc_macro_derive(DefaultUiState, attributes(default_ui_state))] +pub fn derive_default_ui_state(input: TokenStream) -> TokenStream { + let mut output = proc_macro2::TokenStream::new(); + + let state: ItemStruct = parse_macro_input!(input); + + let mut found_attr = false; + let mut state_field = None; + for field in &state.fields { + if !found_attr + && let Type::Path(path) = &field.ty + && path.path.is_ident("DefaultUiState") + { + state_field = Some(field); + } + let Some(attr) = field + .attrs + .iter() + .find(|a| a.path().is_ident("default_ui_state")) + else { + continue; + }; + if found_attr { + output.extend( + Error::new( + attr.span(), + "cannot have more than one default_ui_state attribute", + ) + .into_compile_error(), + ); + continue; + } + found_attr = true; + state_field = Some(field); + } + let Some(field) = state_field else { + output.extend( + Error::new(state.ident.span(), "no DefaultUiState field found").into_compile_error(), + ); + return output.into(); + }; + let sname = &state.ident; + let fname = field.ident.as_ref().unwrap(); + output.extend(quote! { + impl iris::default::HasDefaultUiState for #sname { + fn default_state(&self) -> &iris::default::DefaultUiState { + &self.#fname + } + fn default_state_mut(&mut self) -> &mut iris::default::DefaultUiState { + &mut self.#fname + } + } + }); + output.into() +} + +#[proc_macro_derive(WidgetView, attributes(root))] +pub fn derive_widget_view(input: TokenStream) -> TokenStream { + let mut output = proc_macro2::TokenStream::new(); + + let state: ItemStruct = parse_macro_input!(input); + + let mut found_attr = false; + let mut state_field = None; + for field in &state.fields { + let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("root")) else { + continue; + }; + if found_attr { + output.extend( + Error::new(attr.span(), "cannot have more than one root widget") + .into_compile_error(), + ); + continue; + } + found_attr = true; + state_field = Some(field); + } + let Some(field) = state_field else { + output.extend( + Error::new(state.ident.span(), "no root widget field found (#[root])") + .into_compile_error(), + ); + return output.into(); + }; + let sname = &state.ident; + let fname = field.ident.as_ref().unwrap(); + let fty = &field.ty; + output.extend(quote! { + impl iris::core::WidgetView for #sname { + type Widget = <#fty as iris::core::HasWidget>::Widget; + fn root(&self) -> #fty { + self.#fname + } + } + }); + output.into() +} diff --git a/iris/readme.md b/iris/readme.md new file mode 100644 index 0000000..9bd2147 --- /dev/null +++ b/iris/readme.md @@ -0,0 +1,31 @@ +# iris + +My experimental attempt at a rust ui library (also my first ui library). + +It's currently designed around using retained data structures (widgets), rather than diffing generated trees from data like xilem or iced. This is an experiment and I'm not sure if it's a good idea or not. + +Examples are in `examples`, eg. `cargo run --example tabs`. + +Goals, in general order: +1. does what I want it to (text, images, video, animations) +2. very easy to use ignoring ergonomic ref counting +3. reasonably fast / efficient (a lot faster than electron, save battery life, try to beat iced and xilem) + +## dev details + +not targeting web rn cause wanna use actual nice gpu features & entire point of this is to make desktop apps / not need a web browser + +general ideas trynna use rn / experiment with: +- retained mode +- specifically designed around wgpu so there's no translation +- postfix functions for most things to prevent unreadable indentation (going very well) +- events can be done directly where you draw the widgets +- almost no macros in user code & actual LSP typechecking (variadic generics if you can hear me please save us) +- relative anchor + absolute offset coord system (+ "rest" / leftover during widget layout) +- single threaded ui & pass context around to make non async usage straightforward (pretty unsure about this) +- widgets store outside of the actual rendering so they can be moved around and swapped easily (unsure about this but seems to work good for now) + +under heavy initial development so not gonna try to explain status, maybe check TODO for that; +sizable chance it gets a rewrite once I know everything I need and what seems to work best + +it's called iris because it's the structure around what you actually want to display and colorful diff --git a/iris/src/default/app.rs b/iris/src/default/app.rs new file mode 100644 index 0000000..fe8dfaa --- /dev/null +++ b/iris/src/default/app.rs @@ -0,0 +1,60 @@ +use winit::{ + application::ApplicationHandler, + event::WindowEvent, + event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy}, + window::WindowId, +}; + +pub trait AppState { + type Event: 'static; + fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy) -> Self; + fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop); + fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop); + fn exit(&mut self); + + fn run() + where + Self: Sized, + { + App::::run(); + } +} + +pub struct App { + state: Option, + proxy: EventLoopProxy, +} + +impl App { + pub fn run() { + let event_loop = EventLoop::with_user_event().build().unwrap(); + let proxy = event_loop.create_proxy(); + event_loop + .run_app(&mut App:: { state: None, proxy }) + .unwrap(); + } +} + +impl ApplicationHandler for App { + fn resumed(&mut self, event_loop: &ActiveEventLoop) { + if self.state.is_none() { + let state = State::new(event_loop, self.proxy.clone()); + self.state = Some(state); + } + } + + fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) { + let state = self.state.as_mut().unwrap(); + state.window_event(event, event_loop); + } + + fn user_event(&mut self, event_loop: &ActiveEventLoop, event: State::Event) { + let state = self.state.as_mut().unwrap(); + state.event(event, event_loop); + } + + fn exiting(&mut self, _: &ActiveEventLoop) { + let state = self.state.as_mut().unwrap(); + state.exit(); + } +} diff --git a/iris/src/default/attr.rs b/iris/src/default/attr.rs new file mode 100644 index 0000000..ff4e313 --- /dev/null +++ b/iris/src/default/attr.rs @@ -0,0 +1,78 @@ +use crate::prelude::*; +use std::time::{Duration, Instant}; +use winit::dpi::{LogicalPosition, LogicalSize}; + +pub struct Selector; + +impl WidgetAttr for Selector +where + Rsc::State: HasDefaultUiState, +{ + type Input = WeakWidget; + + fn run(rsc: &mut Rsc, container: WeakWidget, id: Self::Input) { + rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| { + let region = ctx.data.render.window_region(&id).unwrap(); + let id_pos = region.top_left; + let container_pos = ctx.data.render.window_region(&container).unwrap().top_left; + let pos = ctx.data.pos + container_pos - id_pos; + let size = region.size(); + select( + rsc, + ctx.data.render, + ctx.state, + id, + pos, + size, + ctx.data.sense.is_dragging(), + ); + }); + } +} + +pub struct Selectable; + +impl WidgetAttr for Selectable +where + Rsc::State: HasDefaultUiState, +{ + type Input = (); + + fn run(rsc: &mut Rsc, id: WeakWidget, _: Self::Input) { + rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| { + select( + rsc, + ctx.data.render, + ctx.state, + id, + ctx.data.pos, + ctx.data.size, + ctx.data.sense.is_dragging(), + ); + }); + } +} + +fn select( + rsc: &mut impl UiRsc, + render: &UiRenderState, + state: &mut impl HasDefaultUiState, + id: WeakWidget, + pos: Vec2, + size: Vec2, + dragging: bool, +) { + let state = state.default_state_mut(); + let now = Instant::now(); + let recent = (now - state.last_click) < Duration::from_millis(300); + state.last_click = now; + id.edit(rsc).select(pos, size, dragging, recent); + if let Some(region) = render.window_region(&id) { + state.window.set_ime_allowed(true); + state.window.set_ime_cursor_area( + LogicalPosition::::from(region.top_left.tuple()), + LogicalSize::::from(region.size().tuple()), + ); + } + state.focus = Some(id); +} diff --git a/iris/src/default/event.rs b/iris/src/default/event.rs new file mode 100644 index 0000000..b33f09e --- /dev/null +++ b/iris/src/default/event.rs @@ -0,0 +1,9 @@ +use iris_core::Event; + +#[derive(Eq, PartialEq, Hash, Clone)] +pub struct Submit; +impl Event for Submit {} + +#[derive(Eq, PartialEq, Hash, Clone)] +pub struct Edited; +impl Event for Edited {} diff --git a/iris/src/default/input.rs b/iris/src/default/input.rs new file mode 100644 index 0000000..07b6bbf --- /dev/null +++ b/iris/src/default/input.rs @@ -0,0 +1,78 @@ +use crate::prelude::*; +use winit::{ + event::{MouseButton, MouseScrollDelta, WindowEvent}, + keyboard::{Key, NamedKey}, +}; + +#[derive(Default)] +pub struct Input { + cursor: CursorState, + pub modifiers: Modifiers, +} + +impl Input { + pub fn event(&mut self, event: &WindowEvent) -> bool { + match event { + WindowEvent::CursorMoved { position, .. } => { + self.cursor.pos = Vec2::new(position.x as f32, position.y as f32); + self.cursor.exists = true; + } + WindowEvent::MouseInput { state, button, .. } => { + let buttons = &mut self.cursor.buttons; + let pressed = state.is_pressed(); + match button { + MouseButton::Left => buttons.left.update(pressed), + MouseButton::Right => buttons.right.update(pressed), + MouseButton::Middle => buttons.middle.update(pressed), + _ => (), + } + } + WindowEvent::MouseWheel { delta, .. } => { + let mut delta = match *delta { + MouseScrollDelta::LineDelta(x, y) => Vec2::new(x, y), + MouseScrollDelta::PixelDelta(pos) => Vec2::new(pos.x as f32, pos.y as f32), + }; + if delta.x == 0.0 && self.modifiers.shift { + delta.x = delta.y; + delta.y = 0.0; + } + self.cursor.scroll_delta = delta; + } + WindowEvent::CursorLeft { .. } => { + self.cursor.exists = false; + self.modifiers.clear(); + } + WindowEvent::KeyboardInput { event, .. } => { + if let Key::Named(named) = event.logical_key { + let pressed = event.state.is_pressed(); + match named { + NamedKey::Control => { + self.modifiers.control = pressed; + } + NamedKey::Shift => { + self.modifiers.shift = pressed; + } + _ => (), + } + } + } + _ => return false, + } + true + } + + pub fn end_frame(&mut self) { + self.cursor.end_frame(); + } +} + +impl DefaultUiState { + pub fn window_size(&self) -> Vec2 { + let size = self.renderer.window().inner_size(); + (size.width, size.height).into() + } + + pub fn cursor_state(&self) -> &CursorState { + &self.input.cursor + } +} diff --git a/iris/src/default/mod.rs b/iris/src/default/mod.rs new file mode 100644 index 0000000..ea00eb7 --- /dev/null +++ b/iris/src/default/mod.rs @@ -0,0 +1,354 @@ +use crate::prelude::*; +use arboard::Clipboard; +use std::{ + marker::{PhantomData, Sized}, + sync::Arc, + time::Instant, +}; +use winit::{ + event::{Ime, WindowEvent}, + event_loop::{ActiveEventLoop, EventLoopProxy}, + window::{Window, WindowAttributes}, +}; + +mod app; +mod attr; +mod event; +mod input; +mod render; +mod sense; +mod state; +mod task; + +pub use app::*; +pub use attr::*; +pub use event::*; +pub use input::*; +pub use render::*; +pub use sense::*; +pub use state::*; +pub use task::*; + +pub type Proxy = EventLoopProxy; + +pub struct DefaultUiState { + pub root: Option, + pub renderer: UiRenderer, + pub input: Input, + pub focus: Option>, + pub clipboard: Clipboard, + pub window: Arc, + pub ime: usize, + pub last_click: Instant, +} + +impl HasRoot for DefaultUiState { + fn set_root(&mut self, root: StrongWidget) { + self.root = Some(root); + } +} + +impl DefaultUiState { + pub fn new(window: impl Into>) -> Self { + let window = window.into(); + Self { + root: None, + renderer: UiRenderer::new(window.clone()), + window, + input: Input::default(), + clipboard: Clipboard::new().unwrap(), + ime: 0, + last_click: Instant::now(), + focus: None, + } + } +} + +pub trait HasDefaultUiState: Sized + 'static { + fn default_state(&self) -> &DefaultUiState; + fn default_state_mut(&mut self) -> &mut DefaultUiState; +} + +pub trait DefaultAppState: HasDefaultUiState { + type Event = (); + fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc, proxy: Proxy) + -> Self; + #[allow(unused_variables)] + fn event( + &mut self, + event: Self::Event, + rsc: &mut DefaultRsc, + render: &mut UiRenderState, + ) { + } + #[allow(unused_variables)] + fn exit(&mut self, rsc: &mut DefaultRsc, render: &mut UiRenderState) {} + #[allow(unused_variables)] + fn window_event( + &mut self, + event: WindowEvent, + rsc: &mut DefaultRsc, + render: &mut UiRenderState, + ) { + } + fn window_attributes() -> WindowAttributes { + Default::default() + } +} + +pub struct DefaultRsc { + pub ui: UiData, + pub events: EventManager, + pub tasks: Tasks, + pub state: WidgetState, + _state: PhantomData, +} + +impl DefaultRsc { + fn init(window: Arc) -> (Self, TaskMsgReceiver) { + let (tasks, recv) = Tasks::init(window); + ( + Self { + ui: Default::default(), + events: Default::default(), + tasks, + state: Default::default(), + _state: Default::default(), + }, + recv, + ) + } + + pub fn create_state(&mut self, id: impl IdLike, data: T) -> WeakState { + self.state.add(id.id(), data) + } +} + +impl UiRsc for DefaultRsc { + fn ui(&self) -> &UiData { + &self.ui + } + + fn ui_mut(&mut self) -> &mut UiData { + &mut self.ui + } + + fn on_draw(&mut self, active: &ActiveData) { + self.events.draw(active); + } + + fn on_undraw(&mut self, active: &ActiveData) { + self.events.undraw(active); + } + + fn on_remove(&mut self, id: WidgetId) { + self.events.remove(id); + self.state.remove(id); + } +} + +impl HasState for DefaultRsc { + type State = State; +} + +impl HasEvents for DefaultRsc { + fn events(&self) -> &EventManager { + &self.events + } + + fn events_mut(&mut self) -> &mut EventManager { + &mut self.events + } +} + +impl HasTasks for DefaultRsc { + fn tasks_mut(&mut self) -> &mut Tasks { + &mut self.tasks + } +} + +impl HasWidgetState for DefaultRsc { + fn widget_state(&self) -> &WidgetState { + &self.state + } + + fn widget_state_mut(&mut self) -> &mut WidgetState { + &mut self.state + } +} + +pub struct DefaultApp { + rsc: DefaultRsc, + render: UiRenderState, + state: State, + task_recv: TaskMsgReceiver>, +} + +impl AppState for DefaultApp { + type Event = State::Event; + + fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy) -> Self { + let window = event_loop + .create_window(State::window_attributes()) + .unwrap(); + let default_state = DefaultUiState::new(window); + let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone()); + let state = State::new(default_state, &mut rsc, proxy); + let render = UiRenderState::new(); + Self { + rsc, + state, + render, + task_recv, + } + } + + fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) { + self.state.event(event, &mut self.rsc, &mut self.render); + } + + fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) { + let Self { + rsc, + render, + state, + task_recv, + } = self; + + for update in task_recv.try_iter() { + update(state, rsc); + } + + let ui_state = state.default_state_mut(); + let input_changed = ui_state.input.event(&event); + let cursor_state = ui_state.cursor_state().clone(); + let old = ui_state.focus; + if cursor_state.buttons.left.is_start() { + ui_state.focus = None; + } + if input_changed { + let window_size = ui_state.window_size(); + render.run_sensors(rsc, state, cursor_state, window_size); + } + let ui_state = state.default_state_mut(); + if old != ui_state.focus + && let Some(old) = old + { + old.edit(rsc).deselect(); + } + match &event { + WindowEvent::CloseRequested => event_loop.exit(), + WindowEvent::RedrawRequested => { + render.update(&ui_state.root, rsc); + ui_state.renderer.update(&mut rsc.ui, render); + ui_state.renderer.draw(); + } + WindowEvent::Resized(size) => { + render.resize((size.width, size.height)); + ui_state.renderer.resize(size) + } + WindowEvent::KeyboardInput { event, .. } => { + if let Some(sel) = ui_state.focus + && event.state.is_pressed() + { + let mut text = sel.edit(rsc); + match text.apply_event(event, &ui_state.input.modifiers) { + TextInputResult::Unfocus => { + ui_state.focus = None; + ui_state.window.set_ime_allowed(false); + } + TextInputResult::Submit => { + rsc.run_event::(sel, (), state); + } + TextInputResult::Paste => { + if let Ok(t) = ui_state.clipboard.get_text() { + text.insert(&t); + } + rsc.run_event::(sel, (), state); + } + TextInputResult::Copy(text) => { + if let Err(err) = ui_state.clipboard.set_text(text) { + eprintln!("failed to copy text to clipboard: {err}") + } + } + TextInputResult::Used => { + rsc.run_event::(sel, (), state); + } + TextInputResult::Unused => {} + } + } + } + WindowEvent::Ime(ime) => { + if let Some(sel) = ui_state.focus { + let mut text = sel.edit(rsc); + match ime { + Ime::Enabled | Ime::Disabled => (), + Ime::Preedit(content, _pos) => { + // TODO: highlight once that's real + text.replace(ui_state.ime, content); + ui_state.ime = content.chars().count(); + } + Ime::Commit(content) => { + text.insert(content); + } + } + } + } + _ => (), + } + state.window_event(event, rsc, render); + let ui_state = self.state.default_state_mut(); + if render.needs_redraw(&ui_state.root, rsc.widgets()) { + ui_state.renderer.window().request_redraw(); + } + ui_state.input.end_frame(); + } + + fn exit(&mut self) { + self.state.exit(&mut self.rsc, &mut self.render); + } +} + +pub trait RscIdx { + type Output; + fn get(self, rsc: &Rsc) -> &Self::Output; + fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output; +} + +impl>> std::ops::Index for DefaultRsc { + type Output = I::Output; + + fn index(&self, index: I) -> &Self::Output { + index.get(self) + } +} + +impl>> std::ops::IndexMut for DefaultRsc { + fn index_mut(&mut self, index: I) -> &mut Self::Output { + index.get_mut(self) + } +} + +impl RscIdx for WeakWidget { + type Output = W; + + fn get(self, rsc: &Rsc) -> &Self::Output { + &rsc.ui().widgets[self] + } + + fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output { + &mut rsc.ui_mut().widgets[self] + } +} + +impl RscIdx for WeakState { + type Output = T; + + fn get(self, rsc: &Rsc) -> &Self::Output { + rsc.widget_state().get(self) + } + + fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output { + rsc.widget_state_mut().get_mut(self) + } +} diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs new file mode 100644 index 0000000..625a9fa --- /dev/null +++ b/iris/src/default/render.rs @@ -0,0 +1,144 @@ +use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState}; +use pollster::FutureExt; +use std::sync::Arc; +use wgpu::*; +use winit::{dpi::PhysicalSize, window::Window}; + +pub const CLEAR_COLOR: Color = Color::BLACK; + +pub struct UiRenderer { + window: Arc, + surface: Surface<'static>, + device: Device, + queue: Queue, + config: SurfaceConfiguration, + encoder: CommandEncoder, + pub ui: UiRenderNode, +} + +impl UiRenderer { + pub fn update(&mut self, ui: &mut UiData, render: &mut UiRenderState) { + self.ui.update(&self.device, &self.queue, ui, render); + } + + pub fn draw(&mut self) { + let output = self.surface.get_current_texture().unwrap(); + let view = output + .texture + .create_view(&TextureViewDescriptor::default()); + + let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device)); + { + let render_pass = &mut encoder.begin_render_pass(&RenderPassDescriptor { + color_attachments: &[Some(RenderPassColorAttachment { + view: &view, + resolve_target: None, + ops: Operations { + load: LoadOp::Clear(CLEAR_COLOR), + store: StoreOp::Store, + }, + depth_slice: None, + })], + ..Default::default() + }); + self.ui.draw(render_pass); + } + + self.queue.submit(std::iter::once(encoder.finish())); + output.present(); + } + + pub fn resize(&mut self, size: &PhysicalSize) { + self.config.width = size.width; + self.config.height = size.height; + self.surface.configure(&self.device, &self.config); + self.ui.resize(size, &self.queue); + } + + fn create_encoder(device: &Device) -> CommandEncoder { + device.create_command_encoder(&CommandEncoderDescriptor { + label: Some("Render Encoder"), + }) + } + + pub fn new(window: Arc) -> Self { + let size = window.inner_size(); + + let instance = Instance::new(&InstanceDescriptor { + backends: Backends::PRIMARY, + ..Default::default() + }); + + let surface = instance + .create_surface(window.clone()) + .expect("Could not create window surface!"); + + let adapter = instance + .request_adapter(&RequestAdapterOptions { + power_preference: PowerPreference::default(), + compatible_surface: Some(&surface), + force_fallback_adapter: false, + }) + .block_on() + .expect("Could not get adapter!"); + + let ui_limits = UiLimits::default(); + + let (device, queue) = adapter + .request_device(&DeviceDescriptor { + required_features: Features::TEXTURE_BINDING_ARRAY + | Features::PARTIALLY_BOUND_BINDING_ARRAY + | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING, + required_limits: Limits { + max_binding_array_elements_per_shader_stage: ui_limits + .max_binding_array_elements_per_shader_stage(), + max_binding_array_sampler_elements_per_shader_stage: ui_limits + .max_binding_array_sampler_elements_per_shader_stage(), + max_buffer_size: 1 << 30, + ..Default::default() + }, + ..Default::default() + }) + .block_on() + .expect("Could not get device!"); + + let surface_caps = surface.get_capabilities(&adapter); + let surface_format = surface_caps + .formats + .iter() + .copied() + .find(|f| f.is_srgb()) + .unwrap_or(surface_caps.formats[0]); + + let config = SurfaceConfiguration { + usage: TextureUsages::RENDER_ATTACHMENT, + format: surface_format, + width: size.width, + height: size.height, + present_mode: PresentMode::AutoNoVsync, + alpha_mode: surface_caps.alpha_modes[0], + desired_maximum_frame_latency: 2, + view_formats: vec![], + }; + + surface.configure(&device, &config); + + let encoder = Self::create_encoder(&device); + + let ui = UiRenderNode::new(&device, &queue, &config, ui_limits); + + Self { + surface, + device, + queue, + config, + encoder, + ui, + window, + } + } + + pub fn window(&self) -> &Window { + self.window.as_ref() + } +} diff --git a/iris/src/default/sense.rs b/iris/src/default/sense.rs new file mode 100644 index 0000000..ee73ee9 --- /dev/null +++ b/iris/src/default/sense.rs @@ -0,0 +1,308 @@ +use crate::prelude::*; +use std::{ + ops::{BitOr, Deref, DerefMut}, + rc::Rc, +}; + +#[derive(Clone, Copy, PartialEq)] +pub enum CursorButton { + Left, + Right, + Middle, +} + +#[derive(Clone, Copy, PartialEq)] +pub enum CursorSense { + PressStart(CursorButton), + Pressing(CursorButton), + PressEnd(CursorButton), + HoverStart, + Hovering, + HoverEnd, + Scroll, +} + +#[derive(Clone)] +pub struct CursorSenses(Vec); + +impl Event for CursorSenses { + type Data<'a> = CursorData<'a>; + type State = SensorState; + fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option> { + if let Some(sense) = should_run(self, &data.cursor, data.hover) { + let mut data = data.clone(); + data.sense = sense; + Some(data) + } else { + None + } + } +} + +impl CursorSense { + pub fn click() -> Self { + Self::PressStart(CursorButton::Left) + } + pub fn click_or_drag() -> CursorSenses { + Self::click() | Self::Pressing(CursorButton::Left) + } + pub fn unclick() -> Self { + Self::PressEnd(CursorButton::Left) + } + pub fn is_dragging(&self) -> bool { + matches!(self, CursorSense::Pressing(CursorButton::Left)) + } +} + +#[derive(Default, Clone)] +pub struct CursorState { + pub pos: Vec2, + pub exists: bool, + pub buttons: CursorButtons, + pub scroll_delta: Vec2, +} + +#[derive(Default, Clone)] +pub struct CursorButtons { + pub left: ActivationState, + pub middle: ActivationState, + pub right: ActivationState, +} + +impl CursorButtons { + pub fn select(&self, button: &CursorButton) -> &ActivationState { + match button { + CursorButton::Left => &self.left, + CursorButton::Right => &self.right, + CursorButton::Middle => &self.middle, + } + } + + pub fn end_frame(&mut self) { + self.left.end_frame(); + self.middle.end_frame(); + self.right.end_frame(); + } + + pub fn iter(&self) -> impl Iterator { + [ + CursorButton::Left, + CursorButton::Middle, + CursorButton::Right, + ] + .into_iter() + .map(|b| (b, self.select(&b))) + } +} + +impl CursorState { + pub fn end_frame(&mut self) { + self.buttons.end_frame(); + self.scroll_delta = Vec2::ZERO; + } +} + +#[derive(Debug, Clone, Copy, Default, PartialEq)] +pub enum ActivationState { + Start, + On, + End, + #[default] + Off, +} + +/// this and other similar stuff has a generic +/// because I kind of want to make CursorModule generic +/// or basically have some way to have custom senses +/// that depend on active widget positions +/// but I'm not sure how or if worth it +pub struct Sensor { + pub senses: CursorSenses, + pub f: Rc>, +} + +pub type SenseShape = UiRegion; + +#[derive(Default, Debug)] +pub struct SensorState { + pub hover: ActivationState, +} + +#[derive(Clone)] +pub struct CursorData<'a> { + /// where this widget was hit + pub pos: Vec2, + pub size: Vec2, + pub scroll_delta: Vec2, + pub hover: ActivationState, + pub cursor: CursorState, + /// the first sense that triggered this + pub sense: CursorSense, + pub render: &'a UiRenderState, +} + +pub trait SensorUi { + fn run_sensors( + &self, + rsc: &mut Rsc, + state: &mut Rsc::State, + cursor: CursorState, + window_size: Vec2, + ); +} + +impl SensorUi for UiRenderState { + fn run_sensors( + &self, + rsc: &mut Rsc, + state: &mut Rsc::State, + cursor: CursorState, + window_size: Vec2, + ) { + // in order to remove this take, need to store active list in UiRenderState somehow + // this would probably be done through a generic parameter that adds yet another rsc / + // state like thing, but local to render state, and is passed to UiRsc events so you can + // update it there? + let mut active = std::mem::take(&mut rsc.events_mut().get_type::().active); + for layer in self.layers.indices().rev() { + let mut sensed = false; + for (id, sensor) in active.get_mut(&layer).into_flat_iter() { + let shape = self.active.get(id).unwrap().region; + let region = shape.to_px(window_size); + let in_shape = cursor.exists && region.contains(cursor.pos); + sensor.hover.update(in_shape); + if sensor.hover == ActivationState::Off { + continue; + } + sensed = true; + + let cursor = cursor.clone(); + + let data = CursorData { + pos: cursor.pos - region.top_left, + size: region.bot_right - region.top_left, + scroll_delta: cursor.scroll_delta, + hover: sensor.hover, + cursor, + // this does not have any meaning; + // might wanna set up Event to have a prepare stage + sense: CursorSense::Hovering, + render: self, + }; + rsc.run_event::(*id, data, state); + } + if sensed { + break; + } + } + rsc.events_mut().get_type::().active = active; + } +} + +pub fn should_run( + senses: &CursorSenses, + cursor: &CursorState, + hover: ActivationState, +) -> Option { + for sense in senses.iter() { + if match sense { + CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(), + CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(), + CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(), + CursorSense::HoverStart => hover.is_start(), + CursorSense::Hovering => hover.is_on(), + CursorSense::HoverEnd => hover.is_end(), + CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO, + } { + return Some(*sense); + } + } + None +} + +impl ActivationState { + pub fn is_start(&self) -> bool { + *self == Self::Start + } + pub fn is_on(&self) -> bool { + *self == Self::Start || *self == Self::On + } + pub fn is_end(&self) -> bool { + *self == Self::End + } + pub fn is_off(&self) -> bool { + *self == Self::End || *self == Self::Off + } + pub fn update(&mut self, on: bool) { + *self = match *self { + Self::Start => match on { + true => Self::On, + false => Self::End, + }, + Self::On => match on { + true => Self::On, + false => Self::End, + }, + Self::End => match on { + true => Self::Start, + false => Self::Off, + }, + Self::Off => match on { + true => Self::Start, + false => Self::Off, + }, + } + } + + pub fn end_frame(&mut self) { + match self { + Self::Start => *self = Self::On, + Self::End => *self = Self::Off, + _ => (), + } + } +} + +impl EventLike for CursorSense { + type Event = CursorSenses; + fn into_event(self) -> Self::Event { + self.into() + } +} + +impl Deref for CursorSenses { + type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for CursorSenses { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl From for CursorSenses { + fn from(val: CursorSense) -> Self { + CursorSenses(vec![val]) + } +} + +impl BitOr for CursorSense { + type Output = CursorSenses; + + fn bitor(self, rhs: Self) -> Self::Output { + CursorSenses(vec![self, rhs]) + } +} + +impl BitOr for CursorSenses { + type Output = Self; + + fn bitor(mut self, rhs: CursorSense) -> Self::Output { + self.0.push(rhs); + self + } +} diff --git a/iris/src/default/state.rs b/iris/src/default/state.rs new file mode 100644 index 0000000..6a5b0b2 --- /dev/null +++ b/iris/src/default/state.rs @@ -0,0 +1,75 @@ +use iris_core::{ + WidgetId, + util::{HashMap, HashSet}, +}; +use std::{ + any::{Any, TypeId}, + marker::PhantomData, +}; + +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +struct Key { + id: WidgetId, + ty: TypeId, + i: usize, +} + +#[derive(Default)] +pub struct WidgetState { + widgets: HashMap>, + counts: HashMap<(WidgetId, TypeId), usize>, + map: HashMap>, +} + +impl WidgetState { + pub fn new() -> Self { + Self::default() + } + pub fn add(&mut self, id: WidgetId, data: T) -> WeakState { + let ty = TypeId::of::(); + let count = self.counts.entry((id, ty)).or_default(); + let i = *count; + let key = Key { ty, i, id }; + self.map.insert(key, Box::new(data)); + self.widgets.entry(id).or_default().insert((ty, i)); + *count += 1; + WeakState { + key, + _pd: PhantomData, + } + } + pub fn remove(&mut self, id: WidgetId) { + for &(ty, i) in self.widgets.get(&id).into_iter().flatten() { + self.map.remove(&Key { id, ty, i }); + } + } + pub fn get(&self, state: WeakState) -> &T { + self.map.get(&state.key).unwrap().downcast_ref().unwrap() + } + pub fn get_mut(&mut self, state: WeakState) -> &mut T { + self.map + .get_mut(&state.key) + .unwrap() + .downcast_mut() + .unwrap() + } +} + +#[derive(Clone, Copy)] +pub struct WeakState { + key: Key, + _pd: PhantomData, +} + +pub trait HasWidgetState { + fn widget_state(&self) -> &WidgetState; + fn widget_state_mut(&mut self) -> &mut WidgetState; +} + +impl<'a, T: 'static> FnOnce<(&'a mut WidgetState,)> for WeakState { + type Output = &'a mut T; + + extern "rust-call" fn call_once(self, (state,): (&'a mut WidgetState,)) -> Self::Output { + state.get_mut(self) + } +} diff --git a/iris/src/default/task.rs b/iris/src/default/task.rs new file mode 100644 index 0000000..36b55c1 --- /dev/null +++ b/iris/src/default/task.rs @@ -0,0 +1,82 @@ +use iris_core::HasState; +use std::{ + pin::Pin, + sync::{ + Arc, + mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel}, + }, +}; +use tokio::{ + runtime::Runtime, + sync::mpsc::{ + UnboundedReceiver as AsyncReceiver, UnboundedSender as AsyncSender, + unbounded_channel as async_channel, + }, +}; +use winit::window::Window; + +pub type TaskMsgSender = SyncSender>>; +pub type TaskMsgReceiver = SyncReceiver>>; + +pub trait TaskUpdate: FnOnce(&mut Rsc::State, &mut Rsc) + Send {} +impl TaskUpdate for F {} + +pub struct Tasks { + start: AsyncSender, + window: Arc, + msg_send: SyncSender>>, +} + +pub struct TaskCtx { + send: TaskMsgSender, +} + +impl TaskCtx { + pub fn update(&mut self, f: impl TaskUpdate + 'static) { + let _ = self.send.send(Box::new(f)); + } +} +impl TaskCtx { + fn new(send: TaskMsgSender) -> Self { + Self { send } + } +} + +type BoxTask = Pin + Send>>; + +impl Tasks { + pub fn init(window: Arc) -> (Self, TaskMsgReceiver) { + let (start, start_recv) = async_channel(); + let (msgs, msgs_recv) = sync_channel(); + std::thread::spawn(|| { + let rt = Runtime::new().unwrap(); + rt.block_on(listen(start_recv)) + }); + ( + Self { + start, + msg_send: msgs, + window, + }, + msgs_recv, + ) + } + + pub fn spawn) + 'static + std::marker::Send>(&mut self, task: F) + where + F::CallOnceFuture: Send, + { + let send = self.msg_send.clone(); + let window = self.window.clone(); + let _ = self.start.send(Box::pin(async move { + task(TaskCtx::new(send)).await; + window.request_redraw(); + })); + } +} + +async fn listen(mut recv: AsyncReceiver) { + while let Some(task) = recv.recv().await { + tokio::spawn(task); + } +} diff --git a/iris/src/event.rs b/iris/src/event.rs new file mode 100644 index 0000000..f740f75 --- /dev/null +++ b/iris/src/event.rs @@ -0,0 +1,87 @@ +use iris_core::*; +use iris_macro::*; +use std::sync::Arc; + +use crate::default::{TaskCtx, TaskUpdate, Tasks}; + +pub trait Eventable: WidgetLike { + fn on( + self, + event: E, + f: impl for<'a> WidgetEventFn::Data<'a>, Self::Widget>, + ) -> impl WidgetIdFn { + move |rsc| { + let id = self.add(rsc); + rsc.register_event(id, event.into_event(), move |ctx, rsc| { + f( + EventIdCtx { + widget: id, + state: ctx.state, + data: ctx.data, + }, + rsc, + ); + }); + id + } + } +} +impl, Rsc: HasEvents, Tag> Eventable for WL {} + +widget_trait! { + pub trait TaskEventable; + fn task_on<'a, E: EventLike, F: AsyncWidgetEventFn>( + self, + event: E, + f: F, + ) -> impl WidgetIdFn + where ::Data<'a>: Send, + for<'b> F::CallRefFuture<'b>: Send, + { + let f = Arc::new(f); + move |rsc| { + let id = self.add(rsc); + rsc.register_event(id, event.into_event(), move |_, rsc| { + let f = f.clone(); + rsc.tasks_mut().spawn(async move |task| { + f(AsyncEventIdCtx { + widget: id, + task, + }).await; + }); + }); + id + } + } +} + +pub trait HasTasks: Sized + HasState + HasEvents { + fn tasks_mut(&mut self) -> &mut Tasks; + + fn spawn_task) + 'static + std::marker::Send>(&mut self, task: F) + where + F::CallOnceFuture: Send, + { + self.tasks_mut().spawn(task); + } +} + +pub trait AsyncWidgetEventFn: + AsyncFn(AsyncEventIdCtx) + Send + Sync + 'static +{ +} +impl) + Send + Sync + 'static, W: ?Sized> + AsyncWidgetEventFn for F +{ +} + +pub struct AsyncEventIdCtx { + pub widget: WeakWidget, + task: TaskCtx, +} + +impl AsyncEventIdCtx { + pub fn update(&mut self, f: impl TaskUpdate + 'static) { + self.task.update(f); + } +} diff --git a/iris/src/lib.rs b/iris/src/lib.rs new file mode 100644 index 0000000..fa54bba --- /dev/null +++ b/iris/src/lib.rs @@ -0,0 +1,26 @@ +#![feature(unboxed_closures)] +#![feature(fn_traits)] +#![feature(gen_blocks)] +#![feature(associated_type_defaults)] +#![feature(unsize)] +#![feature(option_into_flat_iter)] +#![feature(async_fn_traits)] + +pub mod default; +pub mod event; +pub mod widget; + +pub use iris_core as core; +pub use iris_macro as macros; + +pub mod prelude { + use super::*; + pub use default::*; + pub use event::*; + pub use iris_core::*; + pub use iris_macro::*; + pub use widget::*; + + pub use iris_core::util::Vec2; + pub use len_fns::*; +} diff --git a/iris/src/widget/event.rs b/iris/src/widget/event.rs new file mode 100644 index 0000000..e69de29 diff --git a/iris/src/widget/image.rs b/iris/src/widget/image.rs new file mode 100644 index 0000000..244bbb8 --- /dev/null +++ b/iris/src/widget/image.rs @@ -0,0 +1,55 @@ +use crate::prelude::*; +use image::DynamicImage; + +pub struct Image { + handle: TextureHandle, +} + +impl Widget for Image { + fn draw(&mut self, painter: &mut Painter) { + painter.texture(&self.handle); + } + + fn desired_width(&mut self, _: &mut SizeCtx) -> Len { + Len::abs(self.handle.size().x) + } + + fn desired_height(&mut self, _: &mut SizeCtx) -> Len { + Len::abs(self.handle.size().y) + } +} + +pub fn image(image: impl LoadableImage) -> impl WidgetFn { + let image = image.get_image().expect("Failed to load image"); + move |state| Image { + handle: state.ui_mut().textures.add(image), + } +} + +pub trait LoadableImage { + fn get_image(self) -> Result; +} + +impl LoadableImage for &str { + fn get_image(self) -> Result { + image::open(self).map_err(|e| format!("{e:?}")) + } +} + +impl LoadableImage for String { + fn get_image(self) -> Result { + image::open(self).map_err(|e| format!("{e:?}")) + } +} + +impl LoadableImage for &[u8; LEN] { + fn get_image(self) -> Result { + image::load_from_memory(self).map_err(|e| format!("{e:?}")) + } +} + +impl LoadableImage for DynamicImage { + fn get_image(self) -> Result { + Ok(self) + } +} diff --git a/iris/src/widget/mask.rs b/iris/src/widget/mask.rs new file mode 100644 index 0000000..cc075e9 --- /dev/null +++ b/iris/src/widget/mask.rs @@ -0,0 +1,20 @@ +use crate::prelude::*; + +pub struct Masked { + pub inner: StrongWidget, +} + +impl Widget for Masked { + fn draw(&mut self, painter: &mut Painter) { + painter.set_mask(painter.region()); + painter.widget(&self.inner); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.width(&self.inner) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.height(&self.inner) + } +} diff --git a/iris/src/widget/mod.rs b/iris/src/widget/mod.rs new file mode 100644 index 0000000..016fbe8 --- /dev/null +++ b/iris/src/widget/mod.rs @@ -0,0 +1,15 @@ +mod image; +mod mask; +mod position; +mod ptr; +mod rect; +mod text; +mod trait_fns; + +pub use image::*; +pub use mask::*; +pub use position::*; +pub use ptr::*; +pub use rect::*; +pub use text::*; +pub use trait_fns::*; diff --git a/iris/src/widget/position/align.rs b/iris/src/widget/position/align.rs new file mode 100644 index 0000000..1a6d6a5 --- /dev/null +++ b/iris/src/widget/position/align.rs @@ -0,0 +1,35 @@ +use crate::prelude::*; + +pub struct Aligned { + pub inner: StrongWidget, + pub align: Align, +} + +impl Widget for Aligned { + fn draw(&mut self, painter: &mut Painter) { + let region = match self.align.tuple() { + (Some(x), Some(y)) => painter + .size(&self.inner) + .to_uivec2() + .align(RegionAlign { x, y }), + (Some(x), None) => { + let x = painter.size_ctx().width(&self.inner).apply_rest().align(x); + UiRegion::new(x, UiSpan::FULL) + } + (None, Some(y)) => { + let y = painter.size_ctx().height(&self.inner).apply_rest().align(y); + UiRegion::new(UiSpan::FULL, y) + } + (None, None) => UiRegion::FULL, + }; + painter.widget_within(&self.inner, region); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.width(&self.inner) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.height(&self.inner) + } +} diff --git a/iris/src/widget/position/layer.rs b/iris/src/widget/position/layer.rs new file mode 100644 index 0000000..fb2ced3 --- /dev/null +++ b/iris/src/widget/position/layer.rs @@ -0,0 +1,23 @@ +use crate::prelude::*; + +pub struct LayerOffset { + pub inner: StrongWidget, + pub offset: usize, +} + +impl Widget for LayerOffset { + fn draw(&mut self, painter: &mut Painter) { + for _ in 0..self.offset { + painter.next_layer(); + } + painter.widget(&self.inner); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.width(&self.inner) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.height(&self.inner) + } +} diff --git a/iris/src/widget/position/max_size.rs b/iris/src/widget/position/max_size.rs new file mode 100644 index 0000000..1a9aa39 --- /dev/null +++ b/iris/src/widget/position/max_size.rs @@ -0,0 +1,48 @@ +use crate::prelude::*; + +pub struct MaxSize { + pub inner: StrongWidget, + pub x: Option, + pub y: Option, +} + +impl MaxSize { + fn apply_to_outer(&self, ctx: &mut SizeCtx) { + if let Some(x) = self.x { + ctx.outer.x.select_len(x.apply_rest()); + } + if let Some(y) = self.y { + ctx.outer.y.select_len(y.apply_rest()); + } + } +} + +impl Widget for MaxSize { + fn draw(&mut self, painter: &mut Painter) { + painter.widget(&self.inner); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + self.apply_to_outer(ctx); + let width = ctx.width(&self.inner); + if let Some(x) = self.x { + let width_px = width.apply_rest().to_abs(ctx.output_size().x); + let x_px = x.apply_rest().to_abs(ctx.output_size().x); + if width_px > x_px { x } else { width } + } else { + width + } + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + self.apply_to_outer(ctx); + let height = ctx.height(&self.inner); + if let Some(y) = self.y { + let height_px = height.apply_rest().to_abs(ctx.output_size().y); + let y_px = y.apply_rest().to_abs(ctx.output_size().y); + if height_px > y_px { y } else { height } + } else { + height + } + } +} diff --git a/iris/src/widget/position/mod.rs b/iris/src/widget/position/mod.rs new file mode 100644 index 0000000..c389b6c --- /dev/null +++ b/iris/src/widget/position/mod.rs @@ -0,0 +1,19 @@ +mod align; +mod layer; +mod max_size; +mod offset; +mod pad; +mod scroll; +mod sized; +mod span; +mod stack; + +pub use align::*; +pub use layer::*; +pub use max_size::*; +pub use offset::*; +pub use pad::*; +pub use scroll::*; +pub use sized::*; +pub use span::*; +pub use stack::*; diff --git a/iris/src/widget/position/offset.rs b/iris/src/widget/position/offset.rs new file mode 100644 index 0000000..da54f69 --- /dev/null +++ b/iris/src/widget/position/offset.rs @@ -0,0 +1,21 @@ +use crate::prelude::*; + +pub struct Offset { + pub inner: StrongWidget, + pub amt: UiVec2, +} + +impl Widget for Offset { + fn draw(&mut self, painter: &mut Painter) { + let region = UiRegion::FULL.offset(self.amt); + painter.widget_within(&self.inner, region); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.width(&self.inner) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.height(&self.inner) + } +} diff --git a/iris/src/widget/position/pad.rs b/iris/src/widget/position/pad.rs new file mode 100644 index 0000000..5619d0f --- /dev/null +++ b/iris/src/widget/position/pad.rs @@ -0,0 +1,134 @@ +use crate::prelude::*; + +pub struct Pad { + pub padding: Padding, + pub inner: StrongWidget, +} + +impl Widget for Pad { + fn draw(&mut self, painter: &mut Painter) { + painter.widget_within(&self.inner, self.padding.region()); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + let width = self.padding.left + self.padding.right; + let height = self.padding.top + self.padding.bottom; + ctx.outer.x.abs -= width; + ctx.outer.y.abs -= height; + let mut size = ctx.width(&self.inner); + size.abs += width; + size + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + let width = self.padding.left + self.padding.right; + let height = self.padding.top + self.padding.bottom; + ctx.outer.x.abs -= width; + ctx.outer.y.abs -= height; + let mut size = ctx.height(&self.inner); + size.abs += height; + size + } +} + +pub struct Padding { + pub left: f32, + pub right: f32, + pub top: f32, + pub bottom: f32, +} + +impl Padding { + pub const ZERO: Self = Self { + left: 0.0, + right: 0.0, + top: 0.0, + bottom: 0.0, + }; + + pub fn uniform(amt: impl UiNum) -> Self { + let amt = amt.to_f32(); + Self { + left: amt, + right: amt, + top: amt, + bottom: amt, + } + } + pub fn region(&self) -> UiRegion { + let mut region = UiRegion::FULL; + region.x.start.abs += self.left; + region.y.start.abs += self.top; + region.x.end.abs -= self.right; + region.y.end.abs -= self.bottom; + region + } + pub fn x(amt: impl UiNum) -> Self { + let amt = amt.to_f32(); + Self { + left: amt, + right: amt, + top: 0.0, + bottom: 0.0, + } + } + pub fn y(amt: impl UiNum) -> Self { + let amt = amt.to_f32(); + Self { + left: 0.0, + right: 0.0, + top: amt, + bottom: amt, + } + } + + pub fn top(amt: impl UiNum) -> Self { + let mut s = Self::ZERO; + s.top = amt.to_f32(); + s + } + + pub fn bottom(amt: impl UiNum) -> Self { + let mut s = Self::ZERO; + s.bottom = amt.to_f32(); + s + } + + pub fn left(amt: impl UiNum) -> Self { + let mut s = Self::ZERO; + s.left = amt.to_f32(); + s + } + + pub fn right(amt: impl UiNum) -> Self { + let mut s = Self::ZERO; + s.right = amt.to_f32(); + s + } + + pub fn with_top(mut self, amt: impl UiNum) -> Self { + self.top = amt.to_f32(); + self + } + + pub fn with_bottom(mut self, amt: impl UiNum) -> Self { + self.bottom = amt.to_f32(); + self + } + + pub fn with_left(mut self, amt: impl UiNum) -> Self { + self.left = amt.to_f32(); + self + } + + pub fn with_right(mut self, amt: impl UiNum) -> Self { + self.right = amt.to_f32(); + self + } +} + +impl From for Padding { + fn from(amt: T) -> Self { + Self::uniform(amt.to_f32()) + } +} diff --git a/iris/src/widget/position/scroll.rs b/iris/src/widget/position/scroll.rs new file mode 100644 index 0000000..c789acc --- /dev/null +++ b/iris/src/widget/position/scroll.rs @@ -0,0 +1,66 @@ +use crate::prelude::*; + +pub struct Scroll { + inner: StrongWidget, + axis: Axis, + amt: f32, + snap_end: bool, + container_len: f32, + content_len: f32, +} + +impl Widget for Scroll { + fn draw(&mut self, painter: &mut Painter) { + let output_len = painter.output_size().axis(self.axis); + let container_len = painter.region().axis(self.axis).len(); + let content_len = painter + .len_axis(&self.inner, self.axis) + .apply_rest() + .within_len(container_len) + .to_abs(output_len); + self.container_len = container_len.to_abs(output_len); + self.content_len = content_len; + + if self.snap_end { + self.amt = self.content_len - self.container_len; + } + self.update_amt(); + + let mut region = UiRegion::FULL.offset(Vec2::from_axis(self.axis, -self.amt, 0.0)); + region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len); + painter.widget_within(&self.inner, region); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.width(&self.inner) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + ctx.height(&self.inner) + } +} + +impl Scroll { + pub fn new(inner: StrongWidget, axis: Axis) -> Self { + Self { + inner, + axis, + amt: 0.0, + snap_end: true, + container_len: 0.0, + content_len: 0.0, + } + } + + pub fn update_amt(&mut self) { + self.amt = self.amt.max(0.0); + let len = (self.content_len - self.container_len).max(0.0); + self.amt = self.amt.min(len); + self.snap_end = self.amt == len; + } + + pub fn scroll(&mut self, amt: f32) { + self.amt -= amt; + self.update_amt(); + } +} diff --git a/iris/src/widget/position/sized.rs b/iris/src/widget/position/sized.rs new file mode 100644 index 0000000..aa1fc58 --- /dev/null +++ b/iris/src/widget/position/sized.rs @@ -0,0 +1,34 @@ +use crate::prelude::*; + +pub struct Sized { + pub inner: StrongWidget, + pub x: Option, + pub y: Option, +} + +impl Sized { + fn apply_to_outer(&self, ctx: &mut SizeCtx) { + if let Some(x) = self.x { + ctx.outer.x.select_len(x.apply_rest()); + } + if let Some(y) = self.y { + ctx.outer.y.select_len(y.apply_rest()); + } + } +} + +impl Widget for Sized { + fn draw(&mut self, painter: &mut Painter) { + painter.widget(&self.inner); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + self.apply_to_outer(ctx); + self.x.unwrap_or_else(|| ctx.width(&self.inner)) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + self.apply_to_outer(ctx); + self.y.unwrap_or_else(|| ctx.height(&self.inner)) + } +} diff --git a/iris/src/widget/position/span.rs b/iris/src/widget/position/span.rs new file mode 100644 index 0000000..ad4f932 --- /dev/null +++ b/iris/src/widget/position/span.rs @@ -0,0 +1,207 @@ +use crate::prelude::*; +use std::marker::PhantomData; + +pub struct Span { + pub children: Vec, + pub dir: Dir, + pub gap: f32, +} + +impl Widget for Span { + fn draw(&mut self, painter: &mut Painter) { + let total = self.len_sum(&mut painter.size_ctx()); + let mut start = UiScalar::rel_min(); + for child in &self.children { + let mut span = UiSpan::FULL; + span.start = start; + let len = painter.len_axis(child, self.dir.axis); + if len.rest > 0.0 { + let offset = UiScalar::new(total.rel, total.abs); + let rel_end = UiScalar::rel(len.rest / total.rest); + let end = (UiScalar::rel_max() + start) - offset; + start = rel_end.within(&start.to(end)); + } + start.abs += len.abs; + start.rel += len.rel; + span.end = start; + let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL); + if self.dir.sign == Sign::Neg { + child_region.flip(self.dir.axis); + } + painter.widget_within(child, child_region); + start.abs += self.gap; + } + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + match self.dir.axis { + Axis::X => self.desired_len(ctx), + Axis::Y => self.desired_ortho(ctx), + } + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + match self.dir.axis { + Axis::X => self.desired_ortho(ctx), + Axis::Y => self.desired_len(ctx), + } + } +} + +impl Span { + pub fn empty(dir: Dir) -> Self { + Self { + children: Vec::new(), + dir, + gap: 0.0, + } + } + + pub fn gap(mut self, gap: impl UiNum) -> Self { + self.gap = gap.to_f32(); + self + } + + pub fn push(&mut self, w: StrongWidget) { + self.children.push(w); + } + + pub fn pop(&mut self) -> Option { + self.children.pop() + } + + fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len { + let gap = self.gap * self.children.len().saturating_sub(1) as f32; + self.children.iter().fold(Len::abs(gap), |mut s, id| { + // it's tempting to subtract the abs & rel from the ctx outer, + // but that would create inconsistent sizing if you put + // a rest first vs last & only speed up in one direction. + // I think this is only solvable by restricting how you can + // compute size, bc currently you need child to define parent's + // sectioning and you need parent's sectioning to define child. + // Fortunately, that doesn't matter in most cases + let len = ctx.len_axis(id, self.dir.axis); + s += len; + s + }) + } + + fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len { + let len = self.len_sum(ctx); + if len.rest == 0.0 && len.rel == 0.0 { + len + } else { + Len::default() + } + } + + fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len { + // this is a weird hack to get text wrapping to work properly when in a downward span + // the correct solution here is to add a function to widget that lets them + // request that ctx.outer has an axis "resolved" before checking the other, + // and panicking or warning if two request opposite axis (unsolvable in that case) + let outer = ctx.outer.axis(self.dir.axis); + if self.dir.axis == Axis::X { + // so....... this literally copies draw so that the lengths are correctly set in the + // context, which makes this slow and not cool + let total = self.len_sum(ctx); + let mut start = UiScalar::rel_min(); + let mut ortho_len = Len::ZERO; + for child in &self.children { + let mut span = UiSpan::FULL; + span.start = start; + let len = ctx.len_axis(child, self.dir.axis); + if len.rest > 0.0 { + let offset = UiScalar::new(total.rel, total.abs); + let rel_end = UiScalar::rel(len.rest / total.rest); + let end = (UiScalar::rel_max() + start) - offset; + start = rel_end.within(&start.to(end)); + } + start.abs += len.abs; + start.rel += len.rel; + span.end = start; + + let scalar = span.len(); + *ctx.outer.axis_mut(self.dir.axis) = outer.select_len(scalar); + let ortho = ctx.len_axis(child, !self.dir.axis); + // TODO: rel shouldn't do this, but no easy way before actually calculating pixels + if ortho.rel > 0.0 || ortho.rest > 0.0 { + ortho_len.rest = 1.0; + ortho_len.abs = 0.0; + break; + } + ortho_len.abs = ortho_len.abs.max(ortho.abs); + start.abs += self.gap; + } + ortho_len + } else { + let mut ortho_len = Len::ZERO; + let ortho = !self.dir.axis; + for child in &self.children { + let len = ctx.len_axis(child, ortho); + // TODO: rel shouldn't do this, but no easy way before actually calculating pixels + if len.rel > 0.0 || len.rest > 0.0 { + ortho_len.rest = 1.0; + ortho_len.abs = 0.0; + break; + } + ortho_len.abs = ortho_len.abs.max(len.abs); + } + ortho_len + } + } +} + +pub struct SpanBuilder, Tag> { + pub children: Wa, + pub dir: Dir, + pub gap: f32, + _pd: PhantomData<(State, Tag)>, +} + +impl, Tag> WidgetFnTrait + for SpanBuilder +{ + type Widget = Span; + + #[track_caller] + fn run(self, rsc: &mut Rsc) -> Self::Widget { + Span { + children: self.children.add(rsc).arr.into_iter().collect(), + dir: self.dir, + gap: self.gap, + } + } +} + +impl, Tag> + SpanBuilder +{ + pub fn new(children: Wa, dir: Dir) -> Self { + Self { + children, + dir, + gap: 0.0, + _pd: PhantomData, + } + } + + pub fn gap(mut self, gap: impl UiNum) -> Self { + self.gap = gap.to_f32(); + self + } +} + +impl std::ops::Deref for Span { + type Target = Vec; + + fn deref(&self) -> &Self::Target { + &self.children + } +} + +impl std::ops::DerefMut for Span { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.children + } +} diff --git a/iris/src/widget/position/stack.rs b/iris/src/widget/position/stack.rs new file mode 100644 index 0000000..fb4a591 --- /dev/null +++ b/iris/src/widget/position/stack.rs @@ -0,0 +1,80 @@ +use std::marker::PhantomData; + +use crate::prelude::*; + +pub struct Stack { + pub children: Vec, + pub size: StackSize, +} + +impl Widget for Stack { + fn draw(&mut self, painter: &mut Painter) { + let mut iter = self.children.iter(); + if let Some(child) = iter.next() { + painter.child_layer(); + painter.widget(child); + } + for child in iter { + painter.next_layer(); + painter.widget(child); + } + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + match self.size { + StackSize::Default => Len::default(), + StackSize::Child(i) => ctx.width(&self.children[i]), + } + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + match self.size { + StackSize::Default => Len::default(), + StackSize::Child(i) => ctx.height(&self.children[i]), + } + } +} + +#[derive(Default, Debug)] +pub enum StackSize { + #[default] + Default, + Child(usize), +} + +pub struct StackBuilder, Tag> { + pub children: Wa, + pub size: StackSize, + _pd: PhantomData<(State, Tag)>, +} + +impl, Tag> WidgetFnTrait + for StackBuilder +{ + type Widget = Stack; + + #[track_caller] + fn run(self, rsc: &mut Rsc) -> Self::Widget { + Stack { + children: self.children.add(rsc).arr.into_iter().collect(), + size: self.size, + } + } +} + +impl, Tag> + StackBuilder +{ + pub fn new(children: Wa) -> Self { + Self { + children, + size: StackSize::default(), + _pd: PhantomData, + } + } + + pub fn size(mut self, size: StackSize) -> Self { + self.size = size; + self + } +} diff --git a/iris/src/widget/ptr.rs b/iris/src/widget/ptr.rs new file mode 100644 index 0000000..1e6241b --- /dev/null +++ b/iris/src/widget/ptr.rs @@ -0,0 +1,57 @@ +use crate::prelude::*; +use std::marker::{Sized, Unsize}; + +pub struct WidgetPtr { + pub inner: Option, +} + +impl Widget for WidgetPtr { + fn draw(&mut self, painter: &mut Painter) { + if let Some(id) = &self.inner { + painter.widget(id); + } + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + if let Some(id) = &self.inner { + ctx.width(id) + } else { + Len::ZERO + } + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + if let Some(id) = &self.inner { + ctx.height(id) + } else { + Len::ZERO + } + } +} + +impl WidgetPtr { + pub fn new() -> Self { + Self::default() + } + pub fn empty() -> Self { + Self { + inner: Default::default(), + } + } + pub fn set>(&mut self, to: StrongWidget) { + self.inner = Some(to) + } + + pub fn replace>( + &mut self, + to: StrongWidget, + ) -> Option { + self.inner.replace(to) + } +} + +impl Default for WidgetPtr { + fn default() -> Self { + Self::empty() + } +} diff --git a/iris/src/widget/rect.rs b/iris/src/widget/rect.rs new file mode 100644 index 0000000..f72820e --- /dev/null +++ b/iris/src/widget/rect.rs @@ -0,0 +1,51 @@ +use crate::prelude::*; + +#[derive(Clone, Copy)] +pub struct Rect { + pub color: UiColor, + pub radius: f32, + pub thickness: f32, + pub inner_radius: f32, +} + +impl Rect { + pub fn new(color: UiColor) -> Self { + Self { + color, + radius: 0.0, + inner_radius: 0.0, + thickness: 0.0, + } + } + pub fn color(mut self, color: UiColor) -> Self { + self.color = color; + self + } + pub fn radius(mut self, radius: impl UiNum) -> Self { + self.radius = radius.to_f32(); + self + } +} + +impl Widget for Rect { + fn draw(&mut self, painter: &mut Painter) { + painter.primitive(RectPrimitive { + color: self.color, + radius: self.radius, + thickness: self.thickness, + inner_radius: self.inner_radius, + }); + } + + fn desired_width(&mut self, _: &mut SizeCtx) -> Len { + Len::rest(1) + } + + fn desired_height(&mut self, _: &mut SizeCtx) -> Len { + Len::rest(1) + } +} + +pub fn rect(color: UiColor) -> Rect { + Rect::new(color) +} diff --git a/iris/src/widget/text/build.rs b/iris/src/widget/text/build.rs new file mode 100644 index 0000000..a2e8134 --- /dev/null +++ b/iris/src/widget/text/build.rs @@ -0,0 +1,147 @@ +use crate::prelude::*; +use cosmic_text::{Attrs, Family, Metrics}; +use std::marker::{PhantomData, Sized}; + +pub struct TextBuilder = ()> { + pub content: String, + pub attrs: TextAttrs, + pub hint: H, + pub output: O, + state: PhantomData, +} + +impl> TextBuilder { + pub fn size(mut self, size: impl UiNum) -> Self { + self.attrs.font_size = size.to_f32(); + self.attrs.line_height = self.attrs.font_size * LINE_HEIGHT_MULT; + self + } + pub fn color(mut self, color: UiColor) -> Self { + self.attrs.color = color; + self + } + pub fn family(mut self, family: Family<'static>) -> Self { + self.attrs.family = family; + self + } + pub fn line_height(mut self, height: f32) -> Self { + self.attrs.line_height = height; + self + } + pub fn text_align(mut self, align: impl Into) -> Self { + self.attrs.align = align.into(); + self + } + pub fn center_text(mut self) -> Self { + self.attrs.align = Align::CENTER; + self + } + pub fn wrap(mut self, wrap: bool) -> Self { + self.attrs.wrap = wrap; + self + } + pub fn editable(self, mode: EditMode) -> TextBuilder { + TextBuilder { + content: self.content, + attrs: self.attrs, + hint: self.hint, + output: TextEditOutput { mode }, + state: PhantomData, + } + } +} + +impl TextBuilder { + pub fn hint, Tag>( + self, + hint: W, + ) -> TextBuilder> { + TextBuilder { + content: self.content, + attrs: self.attrs, + hint: move |rsc: &mut Rsc| Some(hint.add_strong(rsc).any()), + output: self.output, + state: PhantomData, + } + } +} + +pub trait TextBuilderOutput: Sized { + type Output; + fn run>( + state: &mut State, + builder: TextBuilder, + ) -> Self::Output; +} + +pub struct TextOutput; +impl TextBuilderOutput for TextOutput { + type Output = Text; + + fn run>( + state: &mut Rsc, + builder: TextBuilder, + ) -> Self::Output { + let mut buf = TextBuffer::new_empty(Metrics::new( + builder.attrs.font_size, + builder.attrs.line_height, + )); + let hint = builder.hint.get(state); + let font_system = &mut state.ui_mut().text.font_system; + buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None); + let mut text = Text { + content: builder.content.into(), + view: TextView::new(buf, builder.attrs, hint), + }; + text.content.changed = false; + builder.attrs.apply(font_system, &mut text.view.buf, None); + text + } +} + +pub struct TextEditOutput { + mode: EditMode, +} + +impl TextBuilderOutput for TextEditOutput { + type Output = TextEdit; + + fn run>( + state: &mut State, + builder: TextBuilder, + ) -> Self::Output { + let buf = TextBuffer::new_empty(Metrics::new( + builder.attrs.font_size, + builder.attrs.line_height, + )); + let mut text = TextEdit::new( + TextView::new(buf, builder.attrs, builder.hint.get(state)), + builder.output.mode, + ); + let font_system = &mut state.ui_mut().text.font_system; + text.buf + .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None); + builder.attrs.apply(font_system, &mut text.buf, None); + text + } +} + +impl, H: WidgetOption> FnOnce<(&mut State,)> + for TextBuilder +{ + type Output = O::Output; + + extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output { + O::run(args.0, self) + } +} + +pub fn wtext(content: impl Into) -> TextBuilder { + TextBuilder { + content: content.into(), + attrs: TextAttrs::default(), + hint: (), + output: TextOutput, + state: PhantomData, + } +} diff --git a/iris/src/widget/text/edit.rs b/iris/src/widget/text/edit.rs new file mode 100644 index 0000000..846d16e --- /dev/null +++ b/iris/src/widget/text/edit.rs @@ -0,0 +1,631 @@ +use crate::prelude::*; +use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion}; +use std::ops::{Deref, DerefMut}; +use unicode_segmentation::UnicodeSegmentation; +use winit::{ + event::KeyEvent, + keyboard::{Key, NamedKey}, +}; + +pub struct TextEdit { + view: TextView, + selection: TextSelection, + history: Vec<(String, TextSelection)>, + double_hit: Option, + pub mode: EditMode, +} + +#[derive(Clone, Copy, PartialEq)] +pub enum EditMode { + SingleLine, + MultiLine, +} + +impl TextEdit { + pub fn new(view: TextView, mode: EditMode) -> Self { + Self { + view, + selection: Default::default(), + history: Default::default(), + double_hit: None, + mode, + } + } + pub fn select_content(&self, start: Cursor, end: Cursor) -> String { + let (start, end) = sort_cursors(start, end); + let mut iter = self.buf.lines.iter().skip(start.line); + let first = iter.next().unwrap(); + if start.line == end.line { + first.text()[start.index..end.index].to_string() + } else { + let mut str = first.text()[start.index..].to_string(); + for _ in (start.line + 1)..end.line { + str = str + "\n" + iter.next().unwrap().text(); + } + let last = iter.next().unwrap(); + str = str + "\n" + &last.text()[..end.index]; + str + } + } +} + +impl Widget for TextEdit { + fn draw(&mut self, painter: &mut Painter) { + let base = painter.layer; + painter.child_layer(); + self.view.draw(painter); + painter.layer = base; + let region = self.region(); + + let size = vec2(1, self.attrs.line_height); + match self.selection { + TextSelection::None => (), + TextSelection::Pos(cursor) => { + if let Some(offset) = cursor_pos(cursor, &self.buf) { + painter.primitive_within( + RectPrimitive::color(Color::WHITE), + size.align(Align::TOP_LEFT).offset(offset).within(®ion), + ); + } + } + TextSelection::Span { start, end } => { + let (start, end) = sort_cursors(start, end); + for (l, x, width) in iter_layout_lines(start, end, &self.buf) { + let top_left = vec2(x, self.attrs.line_height * l as f32); + painter.primitive_within( + RectPrimitive::color(Color::SKY), + size.with_x(width) + .align(Align::TOP_LEFT) + .offset(top_left) + .within(®ion), + ); + } + if let Some(end_offset) = cursor_pos(end, &self.buf) { + painter.primitive_within( + RectPrimitive::color(Color::WHITE), + size.align(Align::TOP_LEFT) + .offset(end_offset) + .within(®ion), + ); + } + } + } + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + self.view.desired_width(ctx) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + self.view.desired_height(ctx) + } +} + +/// provides top left + width +fn iter_layout_lines( + start: Cursor, + end: Cursor, + buf: &TextBuffer, +) -> impl Iterator { + gen move { + let mut iter = buf.layout_runs().enumerate(); + for (i, line) in iter.by_ref() { + if line.line_i == start.line + && let Some(start_x) = index_x(&line, start.index) + { + if start.line == end.line + && let Some(end_x) = index_x(&line, end.index) + { + yield (i, start_x, end_x - start_x); + return; + } + yield (i, start_x, line.line_w - start_x); + break; + } + } + for (i, line) in iter { + if line.line_i > end.line { + return; + } + if line.line_i == end.line + && let Some(end_x) = index_x(&line, end.index) + { + yield (i, 0.0, end_x); + return; + } + yield (i, 0.0, line.line_w); + } + } +} + +/// copied & modified from fn found in Editor in cosmic_text +/// returns x pos of a (non layout) index within an layout run +fn index_x(run: &LayoutRun, index: usize) -> Option { + for glyph in run.glyphs.iter() { + if index == glyph.start { + return Some(glyph.x); + } else if index > glyph.start && index < glyph.end { + // Guess x offset based on characters + let mut before = 0; + let mut total = 0; + + let cluster = &run.text[glyph.start..glyph.end]; + for (i, _) in cluster.grapheme_indices(true) { + if glyph.start + i < index { + before += 1; + } + total += 1; + } + + let offset = glyph.w * (before as f32) / (total as f32); + return Some(glyph.x + offset); + } + } + None +} + +/// returns top of line segment where cursor should visually select +fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option { + let mut prev = None; + for run in buf + .layout_runs() + .skip_while(|r| r.line_i < cursor.line) + .take_while(|r| r.line_i == cursor.line) + { + prev = Some(vec2(run.line_w, run.line_top)); + if let Some(pos) = index_x(&run, cursor.index) { + return Some(vec2(pos, run.line_top)); + } + } + prev +} + +pub struct TextEditCtx<'a> { + pub text: &'a mut TextEdit, + pub font_system: &'a mut FontSystem, +} + +impl<'a> TextEditCtx<'a> { + pub fn take(&mut self) -> String { + let text = self + .text + .buf + .lines + .drain(..) + .map(|l| l.into_text()) + .collect::>() + .join("\n"); + self.text + .buf + .set_text(self.font_system, "", &Attrs::new(), SHAPING, None); + self.text.selection.clear(); + text + } + + pub fn set(&mut self, text: &str) { + let text = self.string(text); + self.text + .buf + .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None); + self.text.selection.clear(); + } + + pub fn motion(&mut self, motion: Motion, select: bool) { + if let TextSelection::Pos(cursor) = self.text.selection + && let Some(new) = self.buf_motion(cursor, motion) + { + if select { + self.text.selection = TextSelection::Span { + start: cursor, + end: new, + }; + } else { + self.text.selection = TextSelection::Pos(new); + } + } else if let TextSelection::Span { start, end } = self.text.selection { + if select { + if let Some(cursor) = self.buf_motion(end, motion) { + self.text.selection = TextSelection::Span { start, end: cursor }; + } + } else { + let (start, end) = sort_cursors(start, end); + let sel = &mut self.text.selection; + match motion { + Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start), + Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end), + _ => { + if let Some(cursor) = self.buf_motion(end, motion) { + self.text.selection = TextSelection::Pos(cursor); + } + } + } + } + } + } + + pub fn replace(&mut self, len: usize, text: &str) { + let text = self.string(text); + for _ in 0..len { + self.delete(false); + } + self.insert_inner(&text, false); + } + + fn string(&self, text: &str) -> String { + if self.text.mode == EditMode::SingleLine { + text.replace('\n', "") + } else { + text.to_string() + } + } + + pub fn insert(&mut self, text: &str) { + let text = self.string(text); + let mut lines = text.split('\n'); + let Some(first) = lines.next() else { + return; + }; + self.insert_inner(first, true); + for line in lines { + self.newline(); + self.insert_inner(line, true); + } + } + + pub fn clear_span(&mut self) -> bool { + if let TextSelection::Span { start, end } = self.text.selection { + self.delete_between(start, end); + let (start, _) = sort_cursors(start, end); + self.text.selection = TextSelection::Pos(start); + true + } else { + false + } + } + + pub fn delete_between(&mut self, start: Cursor, end: Cursor) { + let lines = &mut self.text.view.buf.lines; + let (start, end) = sort_cursors(start, end); + if start.line == end.line { + let line = &mut lines[start.line]; + let text = line.text(); + let text = text[..start.index].to_string() + &text[end.index..]; + edit_line(line, text); + } else { + // start + let start_text = lines[start.line].text()[..start.index].to_string(); + let end_text = &lines[end.line].text()[end.index..]; + let text = start_text + end_text; + edit_line(&mut lines[start.line], text); + } + // between + let range = (start.line + 1)..=end.line; + if !range.is_empty() { + lines.splice(range, None); + } + } + + fn insert_inner(&mut self, text: &str, mov: bool) { + self.clear_span(); + if let TextSelection::Pos(cursor) = &mut self.text.selection { + let line = &mut self.text.view.buf.lines[cursor.line]; + let mut line_text = line.text().to_string(); + line_text.insert_str(cursor.index, text); + edit_line(line, line_text); + if mov { + for _ in 0..text.chars().count() { + self.motion(Motion::Right, false); + } + } + } + } + + pub fn newline(&mut self) { + if self.text.mode == EditMode::SingleLine { + return; + } + self.clear_span(); + if let TextSelection::Pos(cursor) = &mut self.text.selection { + let lines = &mut self.text.view.buf.lines; + let line = &mut lines[cursor.line]; + let new = line.split_off(cursor.index); + cursor.line += 1; + lines.insert(cursor.line, new); + cursor.index = 0; + } + } + + pub fn backspace(&mut self, word: bool) { + if !self.clear_span() + && let TextSelection::Pos(cursor) = &mut self.text.selection + && (cursor.index != 0 || cursor.line != 0) + { + self.motion(if word { Motion::LeftWord } else { Motion::Left }, false); + self.delete(word); + } + } + + pub fn delete(&mut self, word: bool) { + if !self.clear_span() + && let TextSelection::Pos(cursor) = &mut self.text.selection + { + if word { + let start = *cursor; + if let Some(end) = self.buf_motion(start, Motion::RightWord) { + self.delete_between(start, end); + } + } else { + let lines = &mut self.text.view.buf.lines; + let line = &mut lines[cursor.line]; + if cursor.index == line.text().len() { + if cursor.line == lines.len() - 1 { + return; + } + let add = lines.remove(cursor.line + 1).into_text(); + let line = &mut lines[cursor.line]; + let mut cur = line.text().to_string(); + cur.push_str(&add); + edit_line(line, cur); + } else { + let mut text = line.text().to_string(); + text.remove(cursor.index); + edit_line(line, text); + } + } + } + } + + fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option { + self.text + .buf + .cursor_motion(self.font_system, cursor, None, motion) + .map(|r| r.0) + } + + pub fn select_word_at(&mut self, cursor: Cursor) { + if let (Some(start), Some(end)) = ( + self.buf_motion(cursor, Motion::LeftWord), + self.buf_motion(cursor, Motion::RightWord), + ) { + self.text.selection = TextSelection::Span { start, end }; + } + } + + pub fn select_line_at(&mut self, cursor: Cursor) { + let end = self.text.buf.lines[cursor.line].text().len(); + self.text.selection = TextSelection::Span { + start: Cursor::new(cursor.line, 0), + end: Cursor::new(cursor.line, end), + } + } + + pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) { + let pos = pos - self.text.region().top_left().to_abs(size); + let hit = self.text.buf.hit(pos.x, pos.y); + let sel = &mut self.text.selection; + match sel { + TextSelection::None => { + if !drag && let Some(hit) = hit { + *sel = TextSelection::Pos(hit) + } + } + TextSelection::Pos(pos) => match (hit, drag) { + (None, false) => *sel = TextSelection::None, + (None, true) => (), + (Some(hit), false) => { + if recent && hit == *pos { + self.text.double_hit = Some(hit); + return self.select_word_at(hit); + } else { + *pos = hit + } + } + (Some(end), true) => *sel = TextSelection::Span { start: *pos, end }, + }, + TextSelection::Span { start, end } => match (hit, drag) { + (None, false) => *sel = TextSelection::None, + (None, true) => *sel = TextSelection::Pos(*start), + (Some(hit), false) => { + if recent + && let Some(double) = self.text.double_hit + && double == hit + { + return self.select_line_at(hit); + } else { + *sel = TextSelection::Pos(hit) + } + } + (Some(hit), true) => *end = hit, + }, + } + if let TextSelection::Span { start, end } = sel + && start == end + { + *sel = TextSelection::Pos(*start); + } + } + + pub fn deselect(&mut self) { + self.text.selection = TextSelection::None; + } + + pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult { + let old = (self.text.content(), self.text.selection); + let mut undo = false; + let res = self.apply_event_inner(event, modifiers, &mut undo); + if undo && let Some((old, selection)) = self.text.history.pop() { + self.set(&old); + self.text.selection = selection; + } else if self.text.content() != old.0 { + self.text.history.push(old); + } + res + } + + fn apply_event_inner( + &mut self, + event: &KeyEvent, + modifiers: &Modifiers, + undo: &mut bool, + ) -> TextInputResult { + match &event.logical_key { + Key::Named(named) => match named { + NamedKey::Backspace => self.backspace(modifiers.control), + NamedKey::Delete => self.delete(modifiers.control), + NamedKey::Space => self.insert(" "), + NamedKey::Enter => { + if modifiers.shift { + self.newline(); + } else { + return TextInputResult::Submit; + } + } + NamedKey::ArrowRight => { + if modifiers.control { + self.motion(Motion::RightWord, modifiers.shift) + } else { + self.motion(Motion::Right, modifiers.shift) + } + } + NamedKey::ArrowLeft => { + if modifiers.control { + self.motion(Motion::LeftWord, modifiers.shift) + } else { + self.motion(Motion::Left, modifiers.shift) + } + } + NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift), + NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift), + NamedKey::Escape => { + self.deselect(); + return TextInputResult::Unfocus; + } + _ => return TextInputResult::Unused, + }, + Key::Character(text) => { + if modifiers.control { + match text.as_str() { + "v" => return TextInputResult::Paste, + "c" => { + if let TextSelection::Span { start, end } = self.text.selection { + let content = self.text.select_content(start, end); + return TextInputResult::Copy(content); + } + } + "x" => { + if let TextSelection::Span { start, end } = self.text.selection { + let content = self.text.select_content(start, end); + self.clear_span(); + return TextInputResult::Copy(content); + } + } + "a" => { + if !self.text.buf.lines[0].text().is_empty() + || self.text.buf.lines.len() > 1 + { + let lines = &self.text.buf.lines; + let last_line = lines.len() - 1; + let last_idx = lines[last_line].text().len(); + self.text.selection = TextSelection::Span { + start: Cursor::new(0, 0), + end: Cursor::new(last_line, last_idx), + }; + } + } + "z" => { + *undo = true; + } + _ => self.insert(text), + } + } else { + self.insert(text); + } + } + _ => return TextInputResult::Unused, + } + TextInputResult::Used + } +} + +#[derive(Default)] +pub struct Modifiers { + pub shift: bool, + pub control: bool, +} + +impl Modifiers { + pub fn clear(&mut self) { + self.shift = false; + self.control = false; + } +} + +pub enum TextInputResult { + Used, + Unused, + Unfocus, + Submit, + Copy(String), + Paste, +} + +#[derive(Debug, Default, Clone, Copy)] +pub enum TextSelection { + #[default] + None, + Pos(Cursor), + Span { + start: Cursor, + end: Cursor, + }, +} + +impl TextSelection { + pub fn clear(&mut self) { + match self { + TextSelection::None => (), + TextSelection::Pos(cursor) => { + cursor.line = 0; + cursor.index = 0; + cursor.affinity = Affinity::default(); + } + TextSelection::Span { start: _, end: _ } => { + *self = TextSelection::None; + } + } + } +} + +impl TextInputResult { + pub fn unfocus(&self) -> bool { + matches!(self, TextInputResult::Unfocus) + } +} + +impl Deref for TextEdit { + type Target = TextView; + + fn deref(&self) -> &Self::Target { + &self.view + } +} + +impl DerefMut for TextEdit { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.view + } +} + +pub trait TextEditable { + fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a>; +} + +impl> TextEditable for I { + fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a> { + let ui = ui.ui_mut(); + TextEditCtx { + text: ui.widgets.get_mut(self).unwrap(), + font_system: &mut ui.text.font_system, + } + } +} diff --git a/iris/src/widget/text/mod.rs b/iris/src/widget/text/mod.rs new file mode 100644 index 0000000..cc9c94f --- /dev/null +++ b/iris/src/widget/text/mod.rs @@ -0,0 +1,203 @@ +mod build; +mod edit; + +pub use build::*; +pub use edit::*; +use iris_core::util::MutDetect; + +use crate::prelude::*; +use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping}; +use std::ops::{Deref, DerefMut}; + +pub const SHAPING: Shaping = Shaping::Advanced; + +pub struct Text { + pub content: MutDetect, + view: TextView, +} + +pub struct TextView { + pub attrs: MutDetect, + pub buf: MutDetect, + // cache + tex: Option, + width: Option, + pub hint: Option, +} + +impl TextView { + pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option) -> Self { + Self { + attrs: attrs.into(), + buf: buf.into(), + tex: None, + width: None, + hint, + } + } + + /// region where the text should be draw + /// does not include extra height or width from weird unicode + pub fn region(&self) -> UiRegion { + self.tex() + .map(|t| t.size) + .unwrap_or(Vec2::ZERO) + .align(self.align) + } + + fn tex_region(&self, tex: &RenderedText) -> UiRegion { + let region = tex.size.align(self.align); + let dims = tex.handle.size(); + let mut region = region.offset(tex.top_left_offset); + region.x.end = region.x.start + UiScalar::abs(dims.x); + region.y.end = region.y.start + UiScalar::abs(dims.y); + region + } + + fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText { + let width = if self.attrs.wrap { + Some(ctx.px_size().x) + } else { + None + }; + if width == self.width + && let Some(tex) = &self.tex + && !self.attrs.changed + && !self.buf.changed + { + return tex.clone(); + } + self.width = width; + let font_system = &mut ctx.text.font_system; + self.attrs.apply(font_system, &mut self.buf, width); + self.buf.shape_until_scroll(font_system, false); + let tex = ctx.draw_text(&mut self.buf, &self.attrs); + self.tex = Some(tex.clone()); + self.attrs.changed = false; + self.buf.changed = false; + tex + } + pub fn tex(&self) -> Option<&RenderedText> { + self.tex.as_ref() + } + pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + if let Some(hint) = &self.hint + && let [line] = &self.buf.lines[..] + && line.text().is_empty() + { + ctx.width(hint) + } else { + Len::abs(self.render(ctx).size.x) + } + } + pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + if let Some(hint) = &self.hint + && let [line] = &self.buf.lines[..] + && line.text().is_empty() + { + ctx.height(hint) + } else { + Len::abs(self.render(ctx).size.y) + } + } + pub fn draw(&mut self, painter: &mut Painter) -> UiRegion { + let tex = self.render(&mut painter.size_ctx()); + let region = self.tex_region(&tex); + if let Some(hint) = &self.hint + && let [line] = &self.buf.lines[..] + && line.text().is_empty() + { + painter.widget(hint); + } else { + painter.texture_within(&tex.handle, region); + } + region + } + + pub fn content(&self) -> String { + self.buf + .lines + .iter() + .map(|l| l.text()) + .collect::>() + .join("\n") + } +} + +impl Text { + pub fn new(content: impl Into) -> Self { + let attrs = TextAttrs::default(); + let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height)); + Self { + content: content.into().into(), + view: TextView::new(buf, attrs, None), + } + } + fn update_buf(&mut self, ctx: &mut SizeCtx) { + if self.content.changed { + self.content.changed = false; + self.view.buf.set_text( + &mut ctx.text.font_system, + &self.content, + &Attrs::new().family(self.view.attrs.family), + SHAPING, + None, + ); + } + } +} + +impl Widget for Text { + fn draw(&mut self, painter: &mut Painter) { + self.update_buf(&mut painter.size_ctx()); + self.view.draw(painter); + } + + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { + self.update_buf(ctx); + self.view.desired_width(ctx) + } + + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { + self.update_buf(ctx); + self.view.desired_height(ctx) + } +} + +pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) { + let start = a.min(b); + let end = a.max(b); + (start, end) +} + +pub fn edit_line(line: &mut BufferLine, text: String) { + line.set_text(text, line.ending(), line.attrs_list().clone()); +} + +impl Deref for Text { + type Target = TextAttrs; + + fn deref(&self) -> &Self::Target { + &self.view + } +} + +impl DerefMut for Text { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.view + } +} + +impl Deref for TextView { + type Target = TextAttrs; + + fn deref(&self) -> &Self::Target { + &self.attrs + } +} + +impl DerefMut for TextView { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.attrs + } +} diff --git a/iris/src/widget/trait_fns.rs b/iris/src/widget/trait_fns.rs new file mode 100644 index 0000000..effebc8 --- /dev/null +++ b/iris/src/widget/trait_fns.rs @@ -0,0 +1,148 @@ +use super::*; +use crate::prelude::*; + +// these methods should "not require any context" (require unit) because they're in core +widget_trait! { + pub trait CoreWidget; + + fn pad(self, padding: impl Into) -> impl WidgetFn { + |state| Pad { + padding: padding.into(), + inner: self.add_strong(state), + } + } + + fn align(self, align: impl Into) -> impl WidgetFn { + move |state| Aligned { + inner: self.add_strong(state), + align: align.into(), + } + } + + fn center(self) -> impl WidgetFn { + self.align(Align::CENTER) + } + + fn label(self, label: impl Into) -> impl WidgetIdFn { + |state| { + let id = self.add(state); + state.ui_mut().widgets.set_label(id, label.into()); + id + } + } + + fn sized(self, size: impl Into) -> impl WidgetFn { + let size = size.into(); + move |state| Sized { + inner: self.add_strong(state), + x: Some(size.x), + y: Some(size.y), + } + } + + fn max_width(self, len: impl Into) -> impl WidgetFn { + let len = len.into(); + move |state| MaxSize { + inner: self.add_strong(state), + x: Some(len), + y: None, + } + } + + fn max_height(self, len: impl Into) -> impl WidgetFn { + let len = len.into(); + move |state| MaxSize { + inner: self.add_strong(state), + x: None, + y: Some(len), + } + } + + fn width(self, len: impl Into) -> impl WidgetFn { + let len = len.into(); + move |state| Sized { + inner: self.add_strong(state), + x: Some(len), + y: None, + } + } + + fn height(self, len: impl Into) -> impl WidgetFn { + let len = len.into(); + move |state| Sized { + inner: self.add_strong(state), + x: None, + y: Some(len), + } + } + + fn offset(self, amt: impl Into) -> impl WidgetFn { + move |state| Offset { + inner: self.add_strong(state), + amt: amt.into(), + } + } + + fn scrollable(self) -> impl WidgetIdFn where Rsc: HasEvents { + move |state| { + Scroll::new(self.add_strong(state), Axis::Y) + .on(CursorSense::Scroll, |ctx, rsc| { + let delta = ctx.data.scroll_delta.y * 50.0; + ctx.widget(rsc).scroll(delta); + }) + .add(state) + } + } + + fn masked(self) -> impl WidgetFn { + move |state| Masked { + inner: self.add_strong(state), + } + } + + fn background(self, w: impl WidgetLike) -> impl WidgetFn { + move |state| Stack { + children: vec![w.add_strong(state), self.add_strong(state)], + size: StackSize::Child(1), + } + } + + fn foreground(self, w: impl WidgetLike) -> impl WidgetFn { + move |state| Stack { + children: vec![self.add_strong(state), w.add_strong(state)], + size: StackSize::Child(0), + } + } + + fn layer_offset(self, offset: usize) -> impl WidgetFn { + move |state| LayerOffset { + inner: self.add_strong(state), + offset, + } + } + + fn to_any(self) -> impl WidgetIdFn { + |state| self.add(state) + } + + fn set_ptr(self, ptr: WeakWidget, state: &mut Rsc) { + let id = self.add_strong(state); + state.ui_mut().widgets[ptr].inner = Some(id); + } +} + +pub trait CoreWidgetArr, Tag> { + fn span(self, dir: Dir) -> SpanBuilder; + fn stack(self) -> StackBuilder; +} + +impl, Tag> + CoreWidgetArr for Wa +{ + fn span(self, dir: Dir) -> SpanBuilder { + SpanBuilder::new(self, dir) + } + fn stack(self) -> StackBuilder { + StackBuilder::new(self) + } +} From caaa733caae08a683d5151c6973d11a533796c5b Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:47:27 -0400 Subject: [PATCH 03/77] Make iris build: pin a dated nightly and migrate const-trait impls The vendored January tree did not parse at all on a current nightly: 36 errors in iris-core, all from one syntax change. `impl const Trait for T` is now `const impl Trait for T`, with generics on the `impl`. Bounds are unaffected, and the traits were already declared `const trait` -- so the diagnosis recorded in RUST.md was wrong, and pinning back to a January nightly would only have deferred this. Everything else (the unresolved UiVec2/Vec2/impl_op imports, a Color resolving to wgpu_types::Color) cascaded from the seven files that failed to parse. The pin is dated rather than `nightly` because that is exactly the failure: a rolling channel moving under a build Dev Updater runs unattended. It carries the components and Android targets too, so a fresh clone provisions itself. Also drops two `#![feature]` gates the compiler reports as declared and unused, since the build stays warning-clean, and takes rustfmt's import order in attr.rs. Co-Authored-By: Claude Opus 5 --- iris/core/src/attr.rs | 2 +- iris/core/src/lib.rs | 2 -- iris/core/src/num.rs | 10 +++++----- iris/core/src/orientation/align.rs | 2 +- iris/core/src/orientation/axis.rs | 4 ++-- iris/core/src/orientation/pos.rs | 4 ++-- iris/core/src/primitive/color.rs | 4 ++-- iris/core/src/util/math.rs | 17 +++++++++-------- iris/core/src/util/vec2.rs | 2 +- iris/rust-toolchain.toml | 11 +++++++++++ 10 files changed, 34 insertions(+), 24 deletions(-) create mode 100644 iris/rust-toolchain.toml diff --git a/iris/core/src/attr.rs b/iris/core/src/attr.rs index 6d0a28e..e03fb9d 100644 --- a/iris/core/src/attr.rs +++ b/iris/core/src/attr.rs @@ -1,4 +1,4 @@ -use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget}; +use crate::{UiRsc, WeakWidget, WidgetIdFn, WidgetLike}; pub trait WidgetAttr { type Input; diff --git a/iris/core/src/lib.rs b/iris/core/src/lib.rs index f60415a..21882d9 100644 --- a/iris/core/src/lib.rs +++ b/iris/core/src/lib.rs @@ -2,10 +2,8 @@ #![feature(const_ops)] #![feature(const_trait_impl)] #![feature(const_convert)] -#![feature(map_try_insert)] #![feature(unboxed_closures)] #![feature(fn_traits)] -#![feature(const_cmp)] #![feature(const_destruct)] #![feature(portable_simd)] #![feature(associated_type_defaults)] diff --git a/iris/core/src/num.rs b/iris/core/src/num.rs index c4ad5cd..bcd3a08 100644 --- a/iris/core/src/num.rs +++ b/iris/core/src/num.rs @@ -5,19 +5,19 @@ pub const trait UiNum { fn to_f32(self) -> f32; } -impl const UiNum for f32 { +const impl UiNum for f32 { fn to_f32(self) -> f32 { self } } -impl const UiNum for u32 { +const impl UiNum for u32 { fn to_f32(self) -> f32 { self as f32 } } -impl const UiNum for i32 { +const impl UiNum for i32 { fn to_f32(self) -> f32 { self as f32 } @@ -27,7 +27,7 @@ pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 { Vec2::new(x.to_f32(), y.to_f32()) } -impl const From for Vec2 { +const impl From for Vec2 { fn from(v: T) -> Self { Self { x: v.to_f32(), @@ -36,7 +36,7 @@ impl const From for Vec2 { } } -impl const From<(T, U)> for Vec2 +const impl From<(T, U)> for Vec2 where (T, U): const Destruct, { diff --git a/iris/core/src/orientation/align.rs b/iris/core/src/orientation/align.rs index 4fe79d2..876208a 100644 --- a/iris/core/src/orientation/align.rs +++ b/iris/core/src/orientation/align.rs @@ -187,7 +187,7 @@ impl From for Align { } } -impl const From for UiVec2 { +const impl From for UiVec2 { fn from(align: RegionAlign) -> Self { Self::rel(align.rel()) } diff --git a/iris/core/src/orientation/axis.rs b/iris/core/src/orientation/axis.rs index 0f31958..997036a 100644 --- a/iris/core/src/orientation/axis.rs +++ b/iris/core/src/orientation/axis.rs @@ -74,14 +74,14 @@ pub const trait AxisT { } pub struct XAxis; -impl const AxisT for XAxis { +const impl AxisT for XAxis { fn get() -> Axis { Axis::X } } pub struct YAxis; -impl const AxisT for YAxis { +const impl AxisT for YAxis { fn get() -> Axis { Axis::Y } diff --git a/iris/core/src/orientation/pos.rs b/iris/core/src/orientation/pos.rs index 204e048..ae0cbc5 100644 --- a/iris/core/src/orientation/pos.rs +++ b/iris/core/src/orientation/pos.rs @@ -124,13 +124,13 @@ impl Display for UiVec2 { impl_op!(UiVec2 Add add; x y); impl_op!(UiVec2 Sub sub; x y); -impl const From for UiVec2 { +const impl From for UiVec2 { fn from(abs: Vec2) -> Self { Self::abs(abs) } } -impl const From<(T, U)> for UiVec2 +const impl From<(T, U)> for UiVec2 where (T, U): const Destruct, { diff --git a/iris/core/src/primitive/color.rs b/iris/core/src/primitive/color.rs index 1681c2b..fc27f1e 100644 --- a/iris/core/src/primitive/color.rs +++ b/iris/core/src/primitive/color.rs @@ -144,7 +144,7 @@ impl ColorNum for f32 { unsafe impl bytemuck::Pod for Color {} -impl const F32Conversion for f32 { +const impl F32Conversion for f32 { fn to(self) -> f32 { self } @@ -153,7 +153,7 @@ impl const F32Conversion for f32 { } } -impl const F32Conversion for u8 { +const impl F32Conversion for u8 { fn to(self) -> f32 { self as f32 / 255.0 } diff --git a/iris/core/src/util/math.rs b/iris/core/src/util/math.rs index 4bcdbce..4bf4f3a 100644 --- a/iris/core/src/util/math.rs +++ b/iris/core/src/util/math.rs @@ -9,15 +9,16 @@ pub const trait DivOr { fn div_or(self, rhs: Self, other: Self) -> Self; } -impl const DivOr for f32 { +const impl DivOr for f32 { fn div_or(self, rhs: Self, other: Self) -> Self { let res = self / rhs; if res.is_nan() { other } else { res } } } -impl + const Sub + const Mul + const DivOr + Copy> const - LerpUtil for T +const impl< + T: const Add + const Sub + const Mul + const DivOr + Copy, +> LerpUtil for T { /// linear interpolation /// from * (1.0 - self) + to * self @@ -37,7 +38,7 @@ macro_rules! impl_op { use super::*; #[allow(unused_imports)] use std::ops::*; - impl const $op for $T { + const impl $op for $T { type Output = Self; fn $fn(self, rhs: Self) -> Self::Output { @@ -46,12 +47,12 @@ macro_rules! impl_op { } } } - impl const $opa for $T { + const impl $opa for $T { fn $fna(&mut self, rhs: Self) { *self = self.$fn(rhs); } } - impl const $op for $T { + const impl $op for $T { type Output = Self; fn $fn(self, rhs: f32) -> Self::Output { @@ -60,7 +61,7 @@ macro_rules! impl_op { } } } - impl const $op<$T> for f32 { + const impl $op<$T> for f32 { type Output = $T; fn $fn(self, rhs: $T) -> Self::Output { @@ -69,7 +70,7 @@ macro_rules! impl_op { } } } - impl const $opa for $T { + const impl $opa for $T { fn $fna(&mut self, rhs: f32) { *self = self.$fn(rhs); } diff --git a/iris/core/src/util/vec2.rs b/iris/core/src/util/vec2.rs index 7609861..ca67c68 100644 --- a/iris/core/src/util/vec2.rs +++ b/iris/core/src/util/vec2.rs @@ -67,7 +67,7 @@ impl_op!(Vec2 Sub sub; x y); impl_op!(Vec2 Mul mul; x y); impl_op!(Vec2 Div div; x y); -impl const DivOr for Vec2 { +const impl DivOr for Vec2 { fn div_or(self, rhs: Self, other: Self) -> Self { Self { x: self.x.div_or(rhs.x, other.x), diff --git a/iris/rust-toolchain.toml b/iris/rust-toolchain.toml new file mode 100644 index 0000000..7fd6ab2 --- /dev/null +++ b/iris/rust-toolchain.toml @@ -0,0 +1,11 @@ +# iris needs nightly (see the #![feature] list in core/src/lib.rs and src/lib.rs). +# The pin is dated rather than "nightly" because the const-traits feature set +# changes shape between nightlies: on 2026-09-04 the vendored January tree would +# not parse at all, because `impl const Trait for T` had become +# `const impl Trait for T`. A rolling channel turns that into a build that +# breaks unattended on whatever machine Dev Updater happens to build on. +# Advance this deliberately, with the feature list in RUST.md's I0b. +[toolchain] +channel = "nightly-2026-09-03" +components = ["clippy", "rustfmt"] +targets = ["aarch64-linux-android", "x86_64-linux-android"] From 5e23c8b0c0c0be4ce71e861dcf3b308c309cffc9 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:47:27 -0400 Subject: [PATCH 04/77] Add a headless runner for iris examples This VM has no display but does have a real GPU -- Vulkan 1.4 through Venus and GL 4.6 through virgl, onto the host's card -- so the only thing missing for a winit window is a compositor. Same trick `emu` uses for the Android emulator: a headless sway, with grim for the picture. It starts its own compositor rather than joining `emu`'s. sway tiles, so adding a window to the one an emulator sits in resizes that emulator, and a peer session's `emu up` could join at any moment. Xwayland is off here because winit speaks Wayland; `emu` forces it on only because the Android emulator's renderer speaks GLX. It waits for the window to be mapped rather than sleeping a fixed time: the first version's fixed sleep captured an all-black screen when sway had started in the same invocation, which is indistinguishable from an app that draws nothing. Co-Authored-By: Claude Opus 5 --- iris/headless.conf | 14 ++++++ iris/run-headless.sh | 108 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 122 insertions(+) create mode 100644 iris/headless.conf create mode 100755 iris/run-headless.sh diff --git a/iris/headless.conf b/iris/headless.conf new file mode 100644 index 0000000..1f755ca --- /dev/null +++ b/iris/headless.conf @@ -0,0 +1,14 @@ +# The compositor `run-headless.sh` starts, because this machine has no +# display. Nothing here is meant to be looked at directly; `grim` is. +# +# No Xwayland: winit talks Wayland natively, and starting an X server is a +# second thing to go wrong for no gain. (`emu`'s config forces it because the +# Android emulator's renderer speaks GLX.) +xwayland disable + +# A desktop-shaped output, since this is the desktop half of the port. Larger +# than the window an example opens, so nothing is scaled or clipped. +output HEADLESS-1 mode 1920x1200@60Hz + +default_border none +focus_follows_mouse no diff --git a/iris/run-headless.sh b/iris/run-headless.sh new file mode 100755 index 0000000..e253b88 --- /dev/null +++ b/iris/run-headless.sh @@ -0,0 +1,108 @@ +#!/bin/sh +# Run an iris example on this machine, which has no display. +# +# ./run-headless.sh tabs [-- cargo args] +# ./run-headless.sh tabs --shot /tmp/tabs.png --seconds 4 +# +# The VM has a virtio-gpu render node (Vulkan 1.4 through Venus, GL 4.6 +# through virgl), so wgpu runs on the host's real GPU -- what is missing is +# only a compositor to give winit a surface. So: a headless sway, the same +# trick `emu` uses for the Android emulator, and `grim` to see the result. +# +# It is deliberately *not* `emu`'s compositor. sway tiles, so adding a window +# to the one an emulator is sitting in resizes that emulator's window, and a +# peer session's `emu up` could join at any moment. This one has its own +# socket and its own runtime directory and goes away with the machine. +set -eu + +here=$(cd "$(dirname "$0")" && pwd) +run="${XDG_RUNTIME_DIR:-/tmp}/iris-headless" +seconds=3 +shot="" +example="" + +while [ $# -gt 0 ]; do + case "$1" in + --shot) shot=$2; shift 2 ;; + --seconds) seconds=$2; shift 2 ;; + --) shift; break ;; + *) example=$1; shift ;; + esac +done +[ -n "$example" ] || { echo "usage: $0 EXAMPLE [--shot PNG] [--seconds N] [-- cargo args]" >&2; exit 2; } + +mkdir -p "$run" +export SWAYSOCK="$run/sway.sock" + +# Named rather than left to sway's pid-based default, so a second run reuses +# this compositor instead of starting another beside it. +if ! swaymsg -t get_version >/dev/null 2>&1; then + rm -f "$SWAYSOCK" + WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 LIBSEAT_BACKEND=noop \ + setsid sway -c "$here/headless.conf" >"$run/sway.log" 2>&1 & + i=0 + while [ $i -lt 20 ]; do + swaymsg -t get_version >/dev/null 2>&1 && break + i=$((i + 1)); sleep 0.5 + done + swaymsg -t get_version >/dev/null 2>&1 || { + echo "run-headless: compositor did not start; see $run/sway.log" >&2 + exit 1 + } +fi + +# Asked of the compositor rather than guessed: sway takes the first free +# wayland-N, and this machine may already have one. +rm -f "$run/display" +swaymsg exec -- "sh -c 'printf %s \"\$WAYLAND_DISPLAY\" > $run/display'" >/dev/null +i=0 +while [ $i -lt 20 ]; do + [ -s "$run/display" ] && break + i=$((i + 1)); sleep 0.5 +done +[ -s "$run/display" ] || { echo "run-headless: could not read WAYLAND_DISPLAY" >&2; exit 1; } +WAYLAND_DISPLAY=$(cat "$run/display") +export WAYLAND_DISPLAY + +echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2 + +cd "$here" +cargo build --example "$example" "$@" >&2 +bin="$here/target/debug/examples/$example" + +"$bin" >"$run/$example.log" 2>&1 & +pid=$! +trap 'kill "$pid" 2>/dev/null || true' EXIT INT TERM + +# Wait for the window to be mapped rather than for a number of seconds. A +# fixed sleep took an all-black screenshot the first time this ran, when sway +# had started in the same invocation and had not composited its output yet -- +# which is indistinguishable from an app that draws nothing. +i=0 +while [ $i -lt 40 ]; do + kill -0 "$pid" 2>/dev/null || break + swaymsg -t get_tree --raw 2>/dev/null | grep -q "\"pid\":$pid," && break + i=$((i + 1)); sleep 0.25 +done + +# Then settle, for whatever the example does after its first frame. +i=0 +while [ $i -lt "$((seconds * 2))" ]; do + kill -0 "$pid" 2>/dev/null || break + i=$((i + 1)); sleep 0.5 +done + +if kill -0 "$pid" 2>/dev/null; then + [ -n "$shot" ] && grim "$shot" && echo "run-headless: wrote $shot" >&2 + kill "$pid" 2>/dev/null || true + wait "$pid" 2>/dev/null || true + status=0 +else + wait "$pid" 2>/dev/null || status=$? + echo "run-headless: $example exited early (status ${status:-0})" >&2 + status=${status:-1} +fi + +echo "--- $example output ---" >&2 +cat "$run/$example.log" >&2 +exit "$status" From 12221ea025fcac2b5761fd12873cc8bcd3d4770a Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:47:44 -0400 Subject: [PATCH 05/77] Make iris ask for the frame a resize needs `update` redrew everything when `resized` was set, but `needs_redraw` -- which is what decides whether to request a frame at all -- did not know about `resized`. A condition in one and not the other is a frame nobody asks for and a stale window. The two share one `needs_redraw_all` now. Latent on Wayland, because winit requests a redraw after a resize by itself; a resize changes neither the root nor any widget, so nothing else here would have asked. It stops being latent on Android, where the surface work will not have winit underneath it and every rotation and keyboard open is a resize. This is not a fix for the startup defect recorded in RUST.md, where the window keeps its pre-configure layout: that reproduces with this change in place, and the frame it needs is requested and drawn. Co-Authored-By: Claude Opus 5 --- iris/core/src/ui/render_state.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/iris/core/src/ui/render_state.rs b/iris/core/src/ui/render_state.rs index 57e79a6..f5ae8bb 100644 --- a/iris/core/src/ui/render_state.rs +++ b/iris/core/src/ui/render_state.rs @@ -52,7 +52,7 @@ impl UiRenderState { ); } let root = root.into(); - if self.root_changed(root) || self.resized { + if self.needs_redraw_all(root) { self.redraw_all(root, rsc); self.old_root = root.map(|r| r.id()); self.resized = false; @@ -218,12 +218,24 @@ impl UiRenderState { root.into().map(|r| r.id()) != self.old_root } + /// What `update` will redraw everything for. Named and shared with + /// `needs_redraw` rather than written out twice, because the two must + /// agree: `needs_redraw` is what asks for the frame that `update` would + /// draw, so a condition in one and not the other is a frame nobody + /// requests and a stale window. `resized` was missing from `needs_redraw`, + /// which is latent on Wayland only because winit asks for a redraw after a + /// resize by itself -- a resize changes neither the root nor any widget, + /// so nothing else here would have asked. + fn needs_redraw_all<'a>(&self, root: impl Into>) -> bool { + self.root_changed(root) || self.resized + } + pub fn needs_redraw<'a>( &self, root: impl Into>, widgets: &Widgets, ) -> bool { - self.root_changed(root) || widgets.has_updates() + self.needs_redraw_all(root) || widgets.has_updates() } pub fn active_widgets(&self) -> usize { From b6b0928087c61200e2969812f667da099818674d Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:47:44 -0400 Subject: [PATCH 06/77] Take winit out of iris-core, which makes it build for Android iris-core wanted exactly one thing from winit: PhysicalSize in UiRenderNode::resize's signature, for two numbers it immediately turned into floats. That pulled a whole windowing backend into the layer below it. `resize` takes `impl Into` now, matching UiRenderState::resize beside it. The consequence is the reason: with winit in the graph, an Android build of the core failed in android-activity, which needs a backend feature nothing here selects and which iris should not be going through at all -- the plan is android-view. Without it, `cargo ndk -t arm64-v8a -P 26 build -p iris-core` produces an rlib in 30s with wgpu's Android backend included. So the widget, layout and render core already builds for the phone, and what remains is the surface, the input and the IME. Co-Authored-By: Claude Opus 5 --- iris/Cargo.lock | 1 - iris/core/Cargo.toml | 1 - iris/core/src/render/mod.rs | 14 +++++++++----- iris/src/default/render.rs | 2 +- 4 files changed, 10 insertions(+), 8 deletions(-) diff --git a/iris/Cargo.lock b/iris/Cargo.lock index 0796ff1..78e9db3 100644 --- a/iris/Cargo.lock +++ b/iris/Cargo.lock @@ -1070,7 +1070,6 @@ dependencies = [ "fxhash", "image", "wgpu", - "winit", ] [[package]] diff --git a/iris/core/Cargo.toml b/iris/core/Cargo.toml index a85a26d..71edca5 100644 --- a/iris/core/Cargo.toml +++ b/iris/core/Cargo.toml @@ -4,7 +4,6 @@ version.workspace = true edition.workspace = true [dependencies] -winit = { workspace = true } wgpu = { workspace = true } bytemuck ={ workspace = true } image = { workspace = true } diff --git a/iris/core/src/render/mod.rs b/iris/core/src/render/mod.rs index 1695efa..0489ab5 100644 --- a/iris/core/src/render/mod.rs +++ b/iris/core/src/render/mod.rs @@ -3,14 +3,13 @@ use std::num::NonZero; use crate::{ UiData, UiRenderState, render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf}, - util::HashMap, + util::{HashMap, Vec2}, }; use data::WindowUniform; use wgpu::{ util::{BufferInitDescriptor, DeviceExt}, *, }; -use winit::dpi::PhysicalSize; mod data; mod primitive; @@ -118,10 +117,15 @@ impl UiRenderNode { } } - pub fn resize(&mut self, size: &PhysicalSize, queue: &Queue) { + /// Takes a size rather than a window type: this is the only thing the + /// core wanted from winit, and depending on a windowing backend for two + /// numbers is what put `android-activity` in the core's graph for an + /// Android build that is meant to go through android-view instead. + pub fn resize(&mut self, size: impl Into, queue: &Queue) { + let size = size.into(); let slice = &[WindowUniform { - width: size.width as f32, - height: size.height as f32, + width: size.x, + height: size.y, }]; queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice)); } diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs index 625a9fa..970d44c 100644 --- a/iris/src/default/render.rs +++ b/iris/src/default/render.rs @@ -52,7 +52,7 @@ impl UiRenderer { self.config.width = size.width; self.config.height = size.height; self.surface.configure(&self.device, &self.config); - self.ui.resize(size, &self.queue); + self.ui.resize((size.width, size.height), &self.queue); } fn create_encoder(device: &Device) -> CommandEncoder { From e0ee7d6e946a468d3396466a620ebb870ddfde82 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 17:47:44 -0400 Subject: [PATCH 07/77] RUST.md: record E0 and I0b, with what they measured E0 is done (NDK r29, cargo-ndk 4.1.2, verified by cross-compiling to both ABIs) and I0b is done. Corrects this file's guess at why iris would not build, notes the const-traits family as the gates to re-read whenever the pin is advanced, and records the cold build weight against the "slow in debug" worry: 43s and 2.1 GB plain, 1m46s and 1.5 GB with dependencies at opt-level 2. Also records an open defect found on the way -- iris sometimes keeps its pre-configure window size for good -- with what was ruled out, since it is timing-sensitive enough that any added print hides it, and I2 will meet it on every rotation. Co-Authored-By: Claude Opus 5 --- RUST.md | 142 +++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 119 insertions(+), 23 deletions(-) diff --git a/RUST.md b/RUST.md index 202bd03..0ccc49d 100644 --- a/RUST.md +++ b/RUST.md @@ -418,9 +418,20 @@ Android backend wants API 26 (a libc symbol). The real phone has Vulkan. Per the standing rule, a rig limit is something to fix before it is accepted. -- [ ] **E0 — toolchain.** No NDK is installed (`~/Android/Sdk/ndk` is - empty; the Android Rust targets are). Install the NDK under the - user-owned SDK, `cargo-ndk`, and record the versions here. +- [x] **E0 — toolchain (done 2026-09-04).** Installed under the + user-owned SDK: **NDK r29 (`29.0.14206865`)**, 2.4 GB at + `~/Android/Sdk/ndk/29.0.14206865`, the newest stable — r30 is still + at rc.3. **cargo-ndk 4.1.2**. Verified by cross-compiling a scratch + `cdylib` to both ABIs: `file` reports "for Android 26, built by NDK + r29 (14206865)" for `aarch64-linux-android` and + `x86_64-linux-android`. Two things to know at the call site. + **cargo-ndk 4's API-level flag is `-P`, not `-p`** — `-p` is now + passed through to cargo as `--package`, so the old + `cargo ndk -t arm64-v8a -p 26` panics with `unknown package: 26` + *and dumps the whole environment to stdout* as a bug report, which is + worth not doing in a log somebody might paste. And the Android + targets were installed for **stable** only; the pinned nightly needs + its own, which `iris/rust-toolchain.toml` now declares. - [ ] **E1 — android-view's Masonry demo on this emulator.** Pass: it builds with `cargo-ndk` + Gradle, renders on the GPU, and the phone's own keyboard types into its editor with autocorrect and suggestions. @@ -461,26 +472,111 @@ step measured. `7b54aaf` ("readme", 2026-01-29), byte-identical to the public GitHub copy, so a later reconciliation has a known base. A crate that uses it says `iris = { path = "../iris" }`. -- [ ] **I0b — make it build here.** Pin a dated nightly in - `iris/rust-toolchain.toml` (the machine has - `nightly-x86_64-unknown-linux-gnu`, rustc 1.100.0-nightly - 2026-08-25); list every `#![feature]` gate with what it is for, so - each can be retired when it stabilises. Get `cargo build`, `clippy` - and `fmt` clean at the defaults and the `tabs` example running in a - window (this VM has no display: a headless compositor is what - `emu` uses for the emulator, and the same trick serves here). - Pass: a fresh clone builds unattended from the pinned toolchain. - **Measured 2026-09-04**: `cargo +nightly check` on that nightly - fails in `iris-core` with 36 errors, all one cause — the - `const_trait_impl` feature changed shape between January and - August: `impl const Trait for T` is now rejected with "expected a - trait, found type" unless the trait itself is declared - `const trait`, at seven sites (`num.rs`, `align.rs`, `axis.rs`, - `pos.rs`, `color.rs`, `math.rs`, `vec2.rs`), and the unresolved - `UiVec2`/`Vec2`/`impl_op` imports cascade from those. That is the - nightly-drift risk in one build; the fix is mechanical (declare - the traits `const trait`), and it is the first item of I0b rather - than pinning back to a January nightly, which would only defer it. +- [x] **I0b — make it build here (done 2026-09-04).** iris now builds, + clippy-clean and rustfmt-clean at the defaults, on a pinned dated + nightly, and the `tabs` example draws on this VM's GPU. + + **The pin** is `nightly-2026-09-03` (rustc 1.100.0-nightly, + `2e2b193f8`), declared in `iris/rust-toolchain.toml` along with the + `clippy`/`rustfmt` components and the two Android targets, so a + fresh clone provisions itself. It is dated rather than `nightly` + because the whole failure below was a rolling channel moving under + an unattended build. Installed with `--profile minimal`: 912 MB. + + **The 36 errors were one syntax change, and the earlier diagnosis in + this file was wrong.** It is not that a trait must now be declared + `const trait` — the vendored tree already declares them that way, + which is how it was written in January. What changed is the *impl* + keyword order: `impl const Trait for T` is now + `const impl Trait for T`, and generics go on the `impl` + (`const impl Bar for T`). Bounds are unaffected; + `T: const Foo`, `T: [const] Foo` and `impl const Foo` in argument + position all still compile. Everything else — the unresolved + `UiVec2`/`Vec2`/`impl_op` imports, and a `Color` that resolved + to `wgpu_types::Color` — cascaded from the seven files that failed + to parse. The rewrite was mechanical across 20 sites and took the + workspace from 36 errors to 0. + + **`#![feature]` gates, 12 after this step** (two were declared and + unused, and were removed: `map_try_insert`, `const_cmp`). + Load-bearing and worth watching: `const_trait_impl`, `const_ops`, + `const_convert`, `const_destruct` are the const-traits family and + the one that has already broken once — they move together, so + advancing the pin means re-reading this section. `unboxed_closures` + + `fn_traits` (postfix builder API) and `unsize` + + `coerce_unsized` (widget handles) are pairs. The rest are + individually small: `macro_metavar_expr_concat`, `portable_simd`, + `associated_type_defaults`, `option_into_flat_iter`, and `gen_blocks` + in the top crate. + + **Running it headless.** `iris/run-headless.sh EXAMPLE [--shot PNG]` + with `iris/headless.conf`, the same trick `emu` uses: a headless + sway, and `grim` for the picture. It deliberately starts its *own* + compositor rather than joining `emu`'s — sway tiles, so adding a + window to the one an emulator sits in resizes that emulator. + Unlike `emu`'s it disables Xwayland, since winit speaks Wayland. + **This VM has a real GPU for this**: Vulkan 1.4 through Venus onto + the host's RX 7900 XT, and GL 4.6 through virgl — so desktop wgpu + work here is not software-rasterised, unlike inside the emulator. + + **iris has no tests at all** (`cargo test --workspace`: 0 passed + across 6 targets). Nothing to keep passing, and nothing to catch a + regression — worth knowing before I1 changes the text stack. + + **`iris-core` no longer depends on winit, and now cross-compiles to + Android.** It wanted exactly one thing from it — `PhysicalSize` + in `UiRenderNode::resize`'s signature, for two numbers it immediately + turned into floats — and that pulled a whole windowing backend into + the layer below it, the wrong direction. `resize` takes + `impl Into` now, like `UiRenderState::resize` beside it already + did. The consequence is the point: with winit in the graph an Android + build of the core failed in `android-activity` (which needs a backend + feature nothing here selects), and without it + `cargo ndk -t arm64-v8a -P 26 build -p iris-core` finishes in 30s and + produces an rlib, wgpu's Android backend included. So **iris's + widget, layout and render core already builds for the phone**, and + what I2 has to supply is the surface, the input and the IME — not a + port of the library. + + **Build weight, cold, on this VM's 8 cores** (`rm -rf target`, then + `cargo build --example tabs`), since "the Linebender stack is slow in + debug" was the worry behind this question: plain debug **43s** and a + 2.1 GB `target/`; with the `[profile.dev.package."*"] opt-level = 2` + knob, **1m46s** and 1.5 GB. So iris's own wgpu + winit + cosmic-text + graph is not the slow thing — which makes it a calibration for E1 + rather than an answer about Masonry, whose graph adds Vello, Parley, + Fontique and Skrifa. Runtime cost of the knob was not measured here. + + **Open defect found while doing this: iris sometimes never adopts + the window's real size.** Measured on the headless rig, ~3 starts in + 15: the `tabs` example settles showing its 800×600 startup layout in + the top-left of a 1920×1200 surface, black around it, and stays that + way indefinitely — it is not a screenshot taken too early, since the + picture is byte-identical for the next four seconds. What is *not* + the cause, each checked: the winit event order is identical in good + and bad runs (`Resized(800×600)`, two redraws, `Resized(1920×1200)`, + one redraw), the swapchain reports `1920×1200` and + `suboptimal=false` on that last draw, and `output_size` is + `(1920, 1200)` going into it. It is timing-sensitive in the way that + makes it expensive: adding a single `eprintln!` anywhere in the draw + or event path hides it completely (0 in 16), which is why the + instrumentation above could not catch it in the act. A pointer move + does not repair it, because iris only redraws when something + changed; an output mode change does, because that is another resize. + Left open rather than guessed at. It matters most for **I2**, where + every rotation and every keyboard open is a resize, so a stale frame + would be the normal case rather than a rare one; a Wayland-level + trace of the xdg-surface configure/ack/commit sequence is the next + step, not more `eprintln`. + + One thing was fixed on the way, and it is not that bug: `update` + redrew everything when `resized` was set, but `needs_redraw` — which + is what decides whether to *ask* for a frame — did not know about + `resized` at all. The two now share one `needs_redraw_all`, since a + condition in one and not the other is a frame nobody requests. It is + latent on Wayland only because winit asks for a redraw after a resize + by itself; on Android, where the surface work of I2 will not have + winit underneath it, nothing else here would have asked. - [ ] **I1 — the text stack decision.** iris uses cosmic-text; the transcript needs rich inline spans (links, code chips, colour), selection across many widgets with the platform's handles on the From 8d441d3d591a2f320c45dca1dfedd76d9081ea83 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 18:23:10 -0400 Subject: [PATCH 08/77] Present iris with vsync AutoNoVsync accepts frames as fast as the GPU will take them, so a redraw burst costs whatever the hardware can be made to do rather than one frame. That is the wrong default for a toolkit whose stated goal is to save battery, and it is worse than wrong on this machine: the GPU here is the host's real one reached through virtio-gpu, so frames nobody will see are paid for on somebody's desktop. AutoVsync picks Fifo, which every backend supports. Note this is not an idle drain -- iris only draws when needs_redraw says something changed, and the tabs example guards its stats string -- so this bounds the cost of a burst rather than stopping a spin. Co-Authored-By: Claude Opus 5 --- iris/src/default/render.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs index 970d44c..77829cc 100644 --- a/iris/src/default/render.rs +++ b/iris/src/default/render.rs @@ -115,7 +115,14 @@ impl UiRenderer { format: surface_format, width: size.width, height: size.height, - present_mode: PresentMode::AutoNoVsync, + // Vsync, because a UI toolkit aiming at battery life must not + // present frames a display will never show. AutoNoVsync accepts + // them as fast as the GPU will take them, so a redraw burst costs + // whatever the hardware can be made to do rather than one frame -- + // and on this machine the GPU is the host's real one, reached + // through virtio-gpu, so that cost lands on somebody's desktop. + // AutoVsync picks Fifo, which every backend supports. + present_mode: PresentMode::AutoVsync, alpha_mode: surface_caps.alpha_modes[0], desired_maximum_frame_latency: 2, view_formats: vec![], From 10500ae8aa5675235853bbab47a105fff3260180 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 18:38:35 -0400 Subject: [PATCH 09/77] RUST.md: record what E1 showed, and drop an overreaching comment E1 is part-done: the Masonry demo builds with cargo-ndk and Gradle and renders, and ui-trace reads its AccessKit tree, so the bench rig's tap-by-name would work against a Masonry screen. The keyboard half -- the condition the whole framework decision turns on -- was not reached, so the box stays open. Also records that two variables changed at once between the crashing and working runs, so neither can be credited yet. The vsync comment claimed a redraw burst here lands on the host's desktop. That was my attribution for a freeze which turned out not to be mine, and it is machine-specific reasoning that has no business in a library's source. The battery argument is the whole reason and stands on its own. Co-Authored-By: Claude Opus 5 --- RUST.md | 46 ++++++++++++++++++++++++++++++++++++++ iris/src/default/render.rs | 10 ++++----- 2 files changed, 50 insertions(+), 6 deletions(-) diff --git a/RUST.md b/RUST.md index 0ccc49d..ff0493d 100644 --- a/RUST.md +++ b/RUST.md @@ -436,6 +436,52 @@ accepted. builds with `cargo-ndk` + Gradle, renders on the GPU, and the phone's own keyboard types into its editor with autocorrect and suggestions. Note which `wgpu` backend it took and any environment flags needed. + **Part-done 2026-09-04; the keyboard half is untested, so the box + stays open.** + + *Builds and renders.* `~/src/android-view` at `bec6c62`, built with + `cargo ndk -t x86_64 -P 26 -o masonry-app/src/main/jniLibs/ build -p + android-view-masonry-demo` and `./gradlew :masonry-app:assembleDebug`. + The demo draws: its text field and "Add task" button appear, laid out + correctly. Note the demo's README says `arm64-v8a`; this emulator is + x86_64. **`libmain.so` is 181 MB in debug and 11 MB in release**, + which is the single loudest number about Vello's dependency graph. + + *Accessibility works, which E2's condition 6 depends on.* `ui-trace` + reads Masonry's AccessKit tree: "Add task" comes through as a named + `Button` and the editor as an `EditText` node. So the bench rig's + tap-by-name would work against a Masonry screen — for controls that + carry a name. The demo's editor does not, so a coordinate was needed + for it, which is a demo omission rather than a framework one. + + *The keyboard was not reached.* Tapping the editor never brought the + IME up (`mInputShown=false` throughout) before the run ended. Nothing + here says android-view's `InputConnection` does not work — only that + it has not been shown to. This is the half of E1 that matters most, + since it is the constraint the whole framework decision turns on, and + it is what to do first when this is picked up. + + *A crash worth knowing about, seen once.* With an accessibility + client attached the app aborted, and the stack attributes it + precisely: `android_view::view::do_frame` → + `CallbackCtx::finish` → `accesskit_android::event::QueuedEvents::raise` + → `send_completed_event` → `unwrap()` on `Err(JavaException)`. + android-view builds with `panic = "abort"`, so a JNI call that throws + takes the process. It did **not** reproduce: two plain + `ui-trace record` runs afterwards left the app alive, so the trigger + is narrower than "an accessibility client is connected" and is not + yet known. Recorded rather than chased because it is upstream and + one unwrap wide. + + *Two changes were made at once and cannot be separated.* The first + launches crashed in `Surface::configure` ("Invalid surface") on GLES, + then, with Vulkan enabled, segfaulted inside the emulator's own + driver (`vulkan.ranchu.so`, `SetDebugUtilsObjectNameEXT`) while wgpu + labelled an image view — a debug-build-only call. It then ran after + **both** a switch to a release native library and a switch to a + software-rendered emulator. Which of the two fixed it is unmeasured; + whoever picks this up should vary one at a time rather than inherit + the assumption. - [ ] **E2 — a transcript in Masonry.** One screen: open a sandbox session, page 800 events into `VirtualScroll` bottom-anchored, draw markdown from `pulldown-cmark` into Parley rich text with links and code diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs index 77829cc..b317498 100644 --- a/iris/src/default/render.rs +++ b/iris/src/default/render.rs @@ -115,12 +115,10 @@ impl UiRenderer { format: surface_format, width: size.width, height: size.height, - // Vsync, because a UI toolkit aiming at battery life must not - // present frames a display will never show. AutoNoVsync accepts - // them as fast as the GPU will take them, so a redraw burst costs - // whatever the hardware can be made to do rather than one frame -- - // and on this machine the GPU is the host's real one, reached - // through virtio-gpu, so that cost lands on somebody's desktop. + // Vsync, because a toolkit aiming at battery life must not present + // frames a display will never show: AutoNoVsync accepts them as + // fast as the GPU will take them, so a redraw burst costs whatever + // the hardware can be made to do rather than one frame. // AutoVsync picks Fifo, which every backend supports. present_mode: PresentMode::AutoVsync, alpha_mode: surface_caps.alpha_modes[0], From 3fc224b584310fa0bea7edaf184090d45e74109e Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 18:51:10 -0400 Subject: [PATCH 10/77] RUST.md: E1 passes, with the keyboard gap it was there to find The Masonry demo on android-view builds, renders through Vulkan, exposes its AccessKit tree to ui-trace, and takes real keystrokes from the phone's own keyboard. What it does not get is autocorrect and suggestions, and the control is what makes that a finding: the same three key taps in the Settings search field on the same device produce Gboard's suggestion strip, and in Masonry's editor they produce nothing. That is the constraint the framework decision turns on, so it is now the first thing I2 has to answer. Also closes the Vulkan line this file had flagged as untested. The missing step was -no-snapshot-load: the guest keeps the old GPU config from its snapshot and reports zero Vulkan devices however the host is set up. And records the watchdog trap that produced one wrong conclusion on the way -- a bounded run's kill timer must be scoped to the pid it guards, or it fires into somebody else's experiment. Co-Authored-By: Claude Opus 5 --- RUST.md | 131 +++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 83 insertions(+), 48 deletions(-) diff --git a/RUST.md b/RUST.md index ff0493d..f5dc4a3 100644 --- a/RUST.md +++ b/RUST.md @@ -432,56 +432,75 @@ accepted. worth not doing in a log somebody might paste. And the Android targets were installed for **stable** only; the pinned nightly needs its own, which `iris/rust-toolchain.toml` now declares. -- [ ] **E1 — android-view's Masonry demo on this emulator.** Pass: it - builds with `cargo-ndk` + Gradle, renders on the GPU, and the phone's - own keyboard types into its editor with autocorrect and suggestions. - Note which `wgpu` backend it took and any environment flags needed. - **Part-done 2026-09-04; the keyboard half is untested, so the box - stays open.** +- [x] **E1 — android-view's Masonry demo on this emulator (2026-09-04).** + It builds, renders on the GPU through Vulkan, exposes its + accessibility tree, and **the phone's own keyboard types into its + editor** — but with **no autocorrect and no suggestions**. Ticked + because everything it was meant to establish is established, + including the one gap; that gap is now E2's problem and I2's. - *Builds and renders.* `~/src/android-view` at `bec6c62`, built with + *Build.* `~/src/android-view` at `bec6c62`, x86_64 rather than the + README's arm64 because that is what this emulator is: `cargo ndk -t x86_64 -P 26 -o masonry-app/src/main/jniLibs/ build -p - android-view-masonry-demo` and `./gradlew :masonry-app:assembleDebug`. - The demo draws: its text field and "Add task" button appear, laid out - correctly. Note the demo's README says `arm64-v8a`; this emulator is - x86_64. **`libmain.so` is 181 MB in debug and 11 MB in release**, - which is the single loudest number about Vello's dependency graph. + android-view-masonry-demo --release`, then + `./gradlew :masonry-app:assembleDebug`. **`libmain.so` is 181 MB in + debug and 11 MB in release** — the loudest single number about + Vello's dependency graph, and the reason the release build matters + for more than speed. - *Accessibility works, which E2's condition 6 depends on.* `ui-trace` - reads Masonry's AccessKit tree: "Add task" comes through as a named - `Button` and the editor as an `EditText` node. So the bench rig's - tap-by-name would work against a Masonry screen — for controls that - carry a name. The demo's editor does not, so a coordinate was needed - for it, which is a demo omission rather than a framework one. + *Renderer.* wgpu takes **Vulkan**, and the emulator log confirms it + from the other side: `Created VkDevice ... for application:'wgpu'`. + Two things were needed. The emulator must be given Vulkan at all — + `-feature Vulkan` with `VK_DRIVER_FILES` pointing at the SDK's + `vk_swiftshader_icd.json`, **plus `-no-snapshot-load`**, which is the + piece this file had flagged as untested: without a cold boot the + guest keeps the snapshot's old GPU config and `cmd gpu vkjson` + reports zero devices however the host is configured. And the native + library must be **release**: a debug build calls + `SetDebugUtilsObjectNameEXT` to label its image views, and the + emulator's own guest driver (`vulkan.ranchu.so`) segfaults inside it. + On GLES, with no Vulkan available, it instead fails + `Surface::configure` with "Invalid surface" — untriaged, since the + Vulkan path works and Vello wants compute shaders anyway. - *The keyboard was not reached.* Tapping the editor never brought the - IME up (`mInputShown=false` throughout) before the run ended. Nothing - here says android-view's `InputConnection` does not work — only that - it has not been shown to. This is the half of E1 that matters most, - since it is the constraint the whole framework decision turns on, and - it is what to do first when this is picked up. + *Accessibility works*, which E2's condition 6 and every bench script + depend on. `ui-trace` reads Masonry's AccessKit tree: "Add task" + arrives as a named `Button`, the editor as an `EditText` node. So + tap-by-name works against a Masonry screen for any control carrying + a name; the demo's editor carries none, which is the demo's omission + rather than the framework's. - *A crash worth knowing about, seen once.* With an accessibility - client attached the app aborted, and the stack attributes it - precisely: `android_view::view::do_frame` → - `CallbackCtx::finish` → `accesskit_android::event::QueuedEvents::raise` - → `send_completed_event` → `unwrap()` on `Err(JavaException)`. - android-view builds with `panic = "abort"`, so a JNI call that throws - takes the process. It did **not** reproduce: two plain - `ui-trace record` runs afterwards left the app alive, so the trigger - is narrower than "an accessibility client is connected" and is not - yet known. Recorded rather than chased because it is upstream and - one unwrap wide. + *The keyboard: real input yes, suggestions no.* Tapping the editor + opens the actual soft keyboard (`mInputShown=true`, Gboard), and + tapping its keys types into Masonry — "teh" typed key by key, with a + caret. What does **not** appear is Gboard's suggestion strip. The + control is what makes that a finding rather than an impression: the + **same three key taps in the Settings app's search field, on the same + device in the same session, produce "teh | the | yeh"**. So the strip + works here and android-view's editor is not asking for it — most + likely the `EditorInfo` its `InputConnection` reports. That matches + Robrix's report that the Android keyboard is not yet "full", and it + is the single most important thing to fix or fund upstream, because + composition, autocorrect and suggestions are exactly what the + composer in this app needs and exactly what `winit` cannot do at all. + + *One crash seen once and not reproduced.* With an accessibility + client attached the app aborted, stack: + `android_view::view::do_frame` → `CallbackCtx::finish` → + `accesskit_android::event::QueuedEvents::raise` → + `send_completed_event` → `unwrap()` on `Err(JavaException)`. + android-view builds `panic = "abort"`, so a JNI call that throws + takes the process. Two later `ui-trace record` runs left the app + alive, so the trigger is narrower than "a client is attached". + + *A rig trap that cost a wrong conclusion.* Several bounded runs were + given `sleep N; emu down` watchdogs, and one armed for an earlier + experiment fired in the middle of a later one — the app vanished, adb + hung, and it read exactly like the Vulkan path crashing. It was not. + A watchdog must be scoped to the process it guards (`kill $pid`, with + the pid captured at launch) rather than to whatever AVD is running + when it wakes, and only one should be armed at a time. - *Two changes were made at once and cannot be separated.* The first - launches crashed in `Surface::configure` ("Invalid surface") on GLES, - then, with Vulkan enabled, segfaulted inside the emulator's own - driver (`vulkan.ranchu.so`, `SetDebugUtilsObjectNameEXT`) while wgpu - labelled an image view — a debug-build-only call. It then ran after - **both** a switch to a release native library and a switch to a - software-rendered emulator. Which of the two fixed it is unmeasured; - whoever picks this up should vary one at a time rather than inherit - the assumption. - [ ] **E2 — a transcript in Masonry.** One screen: open a sandbox session, page 800 events into `VirtualScroll` bottom-anchored, draw markdown from `pulldown-cmark` into Parley rich text with links and code @@ -683,8 +702,21 @@ re-derived: ### Vulkan in the emulator (measured 2026-09-04) -A `wgpu` app in this emulator was going to get GLES only, because host -Vulkan is switched off in `emulator-tools`. Retried today on Mesa +**Settled 2026-09-04: the guest gets Vulkan from SwiftShader, and the +missing step was a cold boot.** `-feature Vulkan` plus +`VK_DRIVER_FILES=$HOME/Android/Sdk/emulator/lib64/vulkan/vk_swiftshader_icd.json` +gets the *host* side to select SwiftShader, but the guest keeps reporting +zero devices until `-no-snapshot-load` is added, because it boots from a +snapshot saved under the previous GPU config — `-no-snapshot-save` is +worth adding too, so the Vulkan-configured snapshot does not then break +the next ordinary boot. With that, `cmd gpu vkjson` reports SwiftShader +Subzero and wgpu takes its Vulkan path (E1). `EMU_GPU=software` in +`emulator-tools` gets the same guest Vulkan with no GPU use at all, for +work where the emulator's frame rate is not what is being measured. + +The rest of this section stands as the record of why host Vulkan is not +available. A `wgpu` app in this emulator was going to get GLES only, +because host Vulkan is switched off in `emulator-tools`. Retried on Mesa 26.1.7: **Venus still fails the same way** — gfxstream picks `externalMemoryMode: OpaqueFd`, probes `VK_FORMAT_R8G8B8A8_UNORM` for an exportable colour buffer, and Venus says the format is unsupported @@ -717,8 +749,11 @@ booted, then the emulator died right after loading the `default_boot` snapshot with nothing in the log; a snapshot saved under a different Vulkan device is the suspect, and `-no-snapshot-load` is the untested next step. SwiftShader is the one that works today. -Making this an `emu` option belongs in `emulator-tools` and is a shared -tooling change, so it goes through the other sessions first. +`EMU_GPU=software` is now in `emulator-tools` (agreed with the ai-app +session and with Iris, default unchanged, since `-gpu host` was measured +and the Compose scroll benchmarks depend on it). The cold-boot flags are +not a knob there: that wants snapshot invalidation as well, which is a +bigger design question in shared tooling. ## Things a Rust app changes elsewhere From 9b331a5e934be9ce744d0ce297fdae6d7d421bec Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:10:50 -0400 Subject: [PATCH 11/77] Call pre_present_notify, so a settled frame actually reaches the screen About one start in five, the window kept its 800x600 startup layout on a 1920x1200 surface for good. It was not the layout: tracing iris's own decisions into memory -- eprintln in the draw path makes the fault vanish, which is why it kept getting lost -- gives byte-identical traces for a good and a bad run. Both do redraw_all at (1920, 1200) and draw into a 1920x1200 texture with suboptimal=false. The right frame was drawn every time and the compositor kept showing the first one, and forcing a full repaint did not shift it. winit's Window::pre_present_notify, called immediately before present, is what ties the commit to the surface's frame callback on Wayland. Without it a frame with nothing following it can sit unpresented with nothing left to flush it -- which is precisely a window that has just settled after its opening resize. 0 bad in 40 with the fix, against 4 in 20 without. The stronger number is 0 in 20 in the instrumented configuration that had been 15 in 20, since that is the arrangement the fault liked most. Runtime resizing still round-trips to a byte-identical layout. Ruled out and not worth re-trying: the present mode (the fault survived AutoNoVsync -> AutoVsync at the same rate) and the size cache (redraw_all clears it). desired_maximum_frame_latency = 1 moved the rate without fixing it and was reverted. Co-Authored-By: Claude Opus 5 --- RUST.md | 48 +++++++++++++++++++++----------------- iris/src/default/render.rs | 7 ++++++ 2 files changed, 34 insertions(+), 21 deletions(-) diff --git a/RUST.md b/RUST.md index f5dc4a3..8193a80 100644 --- a/RUST.md +++ b/RUST.md @@ -612,27 +612,33 @@ step measured. rather than an answer about Masonry, whose graph adds Vello, Parley, Fontique and Skrifa. Runtime cost of the knob was not measured here. - **Open defect found while doing this: iris sometimes never adopts - the window's real size.** Measured on the headless rig, ~3 starts in - 15: the `tabs` example settles showing its 800×600 startup layout in - the top-left of a 1920×1200 surface, black around it, and stays that - way indefinitely — it is not a screenshot taken too early, since the - picture is byte-identical for the next four seconds. What is *not* - the cause, each checked: the winit event order is identical in good - and bad runs (`Resized(800×600)`, two redraws, `Resized(1920×1200)`, - one redraw), the swapchain reports `1920×1200` and - `suboptimal=false` on that last draw, and `output_size` is - `(1920, 1200)` going into it. It is timing-sensitive in the way that - makes it expensive: adding a single `eprintln!` anywhere in the draw - or event path hides it completely (0 in 16), which is why the - instrumentation above could not catch it in the act. A pointer move - does not repair it, because iris only redraws when something - changed; an output mode change does, because that is another resize. - Left open rather than guessed at. It matters most for **I2**, where - every rotation and every keyboard open is a resize, so a stale frame - would be the normal case rather than a rare one; a Wayland-level - trace of the xdg-surface configure/ack/commit sequence is the next - step, not more `eprintln`. + **Fixed: iris never called `pre_present_notify`.** The symptom was + that about one start in five kept the window's 800x600 startup layout + on a 1920x1200 surface for good. What settled it was tracing iris's + own decisions into memory and dumping them from another thread — + `eprintln!` in the draw path makes the defect vanish, which is why + earlier attempts kept losing it. The traces from a good and a bad run + are **byte-identical**: both lay out and draw `redraw_all at + (1920, 1200)` into a 1920x1200 texture with `suboptimal=false`. iris + was drawing the right frame every time; the compositor was still + showing the first one, and forcing a full repaint did not shift it. + What was missing is winit's `Window::pre_present_notify`, called + immediately before `present`, which on Wayland is what ties the + commit to the surface's frame callback. Without it a frame drawn with + nothing following it can sit unpresented with nothing left to flush + it — which is exactly a window that has just settled after its + opening resize. Measured: **0 bad in 40** with the fix, against 4 in + 20 before it, and — the stronger evidence — 0 in 20 in the + instrumented configuration that had been 15 in 20. Runtime resizing + still round-trips to a byte-identical layout. + + Two things ruled out on the way, both worth not re-trying: the + present mode (the fault survived the move from `AutoNoVsync` to + `AutoVsync` at the same rate) and the size cache (`redraw_all` clears + it). A `desired_maximum_frame_latency` of 1 moved the rate without + fixing it, and was reverted. Iris's own note that she had never seen + the library fail to resize was the useful steer: it pointed away from + the layout code, where two hours had already gone. One thing was fixed on the way, and it is not that bug: `update` redrew everything when `resized` was set, but `needs_redraw` — which diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs index b317498..0004dd1 100644 --- a/iris/src/default/render.rs +++ b/iris/src/default/render.rs @@ -45,6 +45,13 @@ impl UiRenderer { } self.queue.submit(std::iter::once(encoder.finish())); + // Immediately before presenting, so the windowing system can schedule + // the frame. On Wayland this is what ties the commit to the surface's + // frame callback; without it a frame drawn when nothing else follows + // could sit unpresented, and the window kept the layout it had before + // the compositor's first resize -- intermittently, on about a fifth of + // starts, with nothing left to flush it. + self.window.pre_present_notify(); output.present(); } From 68a7f41ed06fe036a121e1ecec23a8b69730f990 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:26:33 -0400 Subject: [PATCH 12/77] Move iris's text onto parley, with a glyph atlas Two changes that only make sense together, because the atlas is what the new layout feeds. Parley replaces cosmic-text for layout and shaping, and its editing model replaces the hand-written one. That is the larger win in edit.rs: parley addresses text by byte offset into one string rather than by (line, index), so `select_content`, `delete_between`, `insert_inner` and `newline` become ordinary string operations, and `iter_layout_lines`, `index_x` and `cursor_pos` -- which walked runs by hand to place the caret and the selection boxes -- are deleted in favour of `Selection::geometry` and `Cursor::geometry`. Those are bidi- and wrap-correct, which the hand-written versions were not. The file loses about 130 lines and gains Home/End. The atlas is what the TODO's "text resizing (per frame) is really slow" was about. Every string used to be rasterised into its own RgbaImage and uploaded as a whole texture whenever anything changed -- so a window resize re-rasterised and re-uploaded every visible string. Now a glyph is rasterised once per font, size and subpixel phase and shared by every string containing it, and a resize re-emits quads without touching the GPU's copy. The tabs example says so directly: its `views` counter, the number of texture views bound, goes from 6 to 1. Supporting pieces: a GLYPH primitive that samples a sub-rectangle and tints it, since the existing texture primitive samples a whole texture; a Patch texture update, because re-uploading a 4 MB page per glyph is what an atlas exists to avoid; and GpuTextures now keeps its Textures, as a view cannot be written through. Two bugs found on the way. `primitives!`'s @count rule recursed with commas while matching space-separated tokens, so it only terminated for exactly two primitives -- adding a third hit the recursion limit. And Color had no Default, which parley's Brush requires. Drops cosmic-text and unicode-segmentation, and with them two nightly feature gates that nothing uses any more: portable_simd (the old glyph compositing) and gen_blocks (the deleted line iterator). Eleven gates left. Co-Authored-By: Claude Opus 5 --- iris/Cargo.lock | 582 ++++++++++++++++++------- iris/Cargo.toml | 8 +- iris/core/Cargo.toml | 3 +- iris/core/src/lib.rs | 1 - iris/core/src/primitive/color.rs | 9 + iris/core/src/primitive/text.rs | 368 ++++++++++------ iris/core/src/primitive/texture.rs | 30 ++ iris/core/src/render/atlas.rs | 234 ++++++++++ iris/core/src/render/mod.rs | 2 + iris/core/src/render/primitive.rs | 31 +- iris/core/src/render/shader.wgsl | 26 ++ iris/core/src/render/texture.rs | 69 ++- iris/core/src/ui/painter.rs | 48 +- iris/core/src/ui/size.rs | 9 +- iris/examples/tabs/main.rs | 1 - iris/src/lib.rs | 1 - iris/src/widget/text/build.rs | 25 +- iris/src/widget/text/edit.rs | 678 ++++++++++++----------------- iris/src/widget/text/mod.rs | 83 ++-- 19 files changed, 1417 insertions(+), 791 deletions(-) create mode 100644 iris/core/src/render/atlas.rs diff --git a/iris/Cargo.lock b/iris/Cargo.lock index 78e9db3..e0239f3 100644 --- a/iris/Cargo.lock +++ b/iris/Cargo.lock @@ -118,7 +118,7 @@ dependencies = [ "clipboard-win", "image", "log", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-app-kit 0.3.2", "objc2-core-foundation", "objc2-core-graphics", @@ -138,7 +138,7 @@ checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -318,7 +318,7 @@ checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -510,39 +510,6 @@ dependencies = [ "memchr", ] -[[package]] -name = "core_maths" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30" -dependencies = [ - "libm", -] - -[[package]] -name = "cosmic-text" -version = "0.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4cadaea21e24c49c0c82116f2b465ae6a49d63c90e428b0f8d9ae1f638ac91f" -dependencies = [ - "bitflags 2.10.0", - "fontdb", - "harfrust", - "linebender_resource_handle", - "log", - "rangemap", - "rustc-hash", - "self_cell", - "skrifa 0.39.0", - "smol_str", - "swash", - "sys-locale", - "unicode-bidi", - "unicode-linebreak", - "unicode-script", - "unicode-segmentation", -] - [[package]] name = "crc32fast" version = "1.5.0" @@ -602,7 +569,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec" dependencies = [ "bitflags 2.10.0", - "objc2 0.6.3", + "objc2 0.6.4", +] + +[[package]] +name = "displaydoc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", ] [[package]] @@ -658,7 +636,7 @@ checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -715,7 +693,7 @@ checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -771,26 +749,34 @@ dependencies = [ ] [[package]] -name = "fontconfig-parser" -version = "0.5.8" +name = "font-types" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646" +checksum = "e64eb721ca85a34323425f4041adc5d82704d3782d5f8f03793bc012419dce23" dependencies = [ - "roxmltree", + "bytemuck", ] [[package]] -name = "fontdb" -version = "0.23.0" +name = "fontique" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905" +checksum = "6688bc1294fe7117d788937b6c53480169b29c566954af490830d4c09da9516a" dependencies = [ - "fontconfig-parser", - "log", + "hashbrown 0.17.1", + "linebender_resource_handle", "memmap2", - "slotmap", - "tinyvec", - "ttf-parser", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-core-text", + "objc2-foundation 0.3.2", + "parlance", + "read-fonts 0.41.0", + "roxmltree", + "smallvec", + "windows", + "windows-core", + "yeslogic-fontconfig-sys", ] [[package]] @@ -811,7 +797,7 @@ checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -941,14 +927,13 @@ dependencies = [ [[package]] name = "harfrust" -version = "0.4.1" +version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0caaee032384c10dd597af4579c67dee16650d862a9ccbe1233ff1a379abc07" +checksum = "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9" dependencies = [ "bitflags 2.10.0", "bytemuck", - "core_maths", - "read-fonts 0.36.0", + "read-fonts 0.41.0", "smallvec", ] @@ -972,6 +957,15 @@ dependencies = [ "foldhash 0.2.0", ] +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash 0.2.0", +] + [[package]] name = "hermit-abi" version = "0.5.2" @@ -984,6 +978,134 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" +[[package]] +name = "icu_collections" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513" +dependencies = [ + "displaydoc", + "potential_utf", + "utf8_iter", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb" +dependencies = [ + "displaydoc", + "litemap", + "serde", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_locale_fallback" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9" +dependencies = [ + "icu_locale_core", + "icu_locale_fallback_data", + "icu_provider", + "potential_utf", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locale_fallback_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8" + +[[package]] +name = "icu_normalizer" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0" + +[[package]] +name = "icu_properties" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa" + +[[package]] +name = "icu_provider" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73" +dependencies = [ + "displaydoc", + "icu_locale_core", + "serde", + "stable_deref_trait", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_segmenter" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82d07aafccd67af15d02512a6adf5896fbc5ed00f2e99b471d2efa14016db3db" +dependencies = [ + "icu_collections", + "icu_locale_fallback", + "icu_provider", + "icu_segmenter_data", + "potential_utf", + "smallvec", + "utf8_iter", + "zerovec", +] + +[[package]] +name = "icu_segmenter_data" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae293c039020f9ec10710af98d29ce6aa2051486638b49c9a6409f3b4a9e98ad" + [[package]] name = "image" version = "0.25.9" @@ -1042,7 +1164,7 @@ checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -1050,13 +1172,13 @@ name = "iris" version = "0.1.0" dependencies = [ "arboard", - "cosmic-text", "image", "iris-core", "iris-macro", + "parley", "pollster", + "swash", "tokio", - "unicode-segmentation", "wgpu", "winit", ] @@ -1066,9 +1188,10 @@ name = "iris-core" version = "0.1.0" dependencies = [ "bytemuck", - "cosmic-text", "fxhash", "image", + "parley", + "swash", "wgpu", ] @@ -1078,7 +1201,7 @@ version = "0.1.0" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -1216,6 +1339,12 @@ version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" +[[package]] +name = "litemap" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae" + [[package]] name = "litrs" version = "1.0.0" @@ -1273,9 +1402,9 @@ checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" [[package]] name = "memmap2" -version = "0.9.9" +version = "0.9.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490" +checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0" dependencies = [ "libc", ] @@ -1410,7 +1539,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -1462,7 +1591,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -1492,9 +1621,9 @@ dependencies = [ [[package]] name = "objc2" -version = "0.6.3" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c2599ce0ec54857b29ce62166b0ed9b4f6f1a70ccc9a71165b6154caca8c05" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" dependencies = [ "objc2-encode", ] @@ -1522,7 +1651,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c" dependencies = [ "bitflags 2.10.0", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-graphics", "objc2-foundation 0.3.2", ] @@ -1571,7 +1700,7 @@ checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" dependencies = [ "bitflags 2.10.0", "dispatch2", - "objc2 0.6.3", + "objc2 0.6.4", ] [[package]] @@ -1582,7 +1711,7 @@ checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" dependencies = [ "bitflags 2.10.0", "dispatch2", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", "objc2-io-surface", ] @@ -1611,6 +1740,16 @@ dependencies = [ "objc2-foundation 0.2.2", ] +[[package]] +name = "objc2-core-text" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d" +dependencies = [ + "bitflags 2.10.0", + "objc2-core-foundation", +] + [[package]] name = "objc2-encode" version = "4.1.0" @@ -1637,7 +1776,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" dependencies = [ "bitflags 2.10.0", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", ] @@ -1648,7 +1787,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" dependencies = [ "bitflags 2.10.0", - "objc2 0.6.3", + "objc2 0.6.4", "objc2-core-foundation", ] @@ -1746,9 +1885,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "orbclient" @@ -1811,6 +1950,39 @@ dependencies = [ "windows-link", ] +[[package]] +name = "parlance" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b6937eda350acc1a5d05872c3cbf99fe78619c269096e2be3d4a350058639d5" + +[[package]] +name = "parley" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22d2ff88bd3f7d68d1d9b09c7e6209f9a8e8c05088295140a2bcf2e9b17038c5" +dependencies = [ + "fontique", + "harfrust", + "hashbrown 0.17.1", + "icu_normalizer", + "icu_properties", + "icu_segmenter", + "linebender_resource_handle", + "parlance", + "parley_data", + "skrifa 0.44.0", +] + +[[package]] +name = "parley_data" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1567535334d6ba2d3cde19221ba9a7bd0fabb3cbd99046ddfb10ae061cfcc889" +dependencies = [ + "icu_properties", +] + [[package]] name = "paste" version = "1.0.15" @@ -1857,7 +2029,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -1920,6 +2092,17 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "potential_utf" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661" +dependencies = [ + "serde_core", + "writeable", + "zerovec", +] + [[package]] name = "ppv-lite86" version = "0.2.21" @@ -1969,7 +2152,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b" dependencies = [ "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -2007,9 +2190,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.42" +version = "1.0.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" dependencies = [ "proc-macro2", ] @@ -2055,12 +2238,6 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde" -[[package]] -name = "rangemap" -version = "1.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "973443cf09a9c8656b574a866ab68dfa19f0867d0340648c7d2f6a71b8a8ea68" - [[package]] name = "rav1e" version = "0.8.1" @@ -2137,16 +2314,6 @@ dependencies = [ "crossbeam-utils", ] -[[package]] -name = "read-fonts" -version = "0.35.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358" -dependencies = [ - "bytemuck", - "font-types", -] - [[package]] name = "read-fonts" version = "0.36.0" @@ -2154,8 +2321,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5eaa2941a4c05443ee3a7b26ab076a553c343ad5995230cc2b1d3e993bdc6345" dependencies = [ "bytemuck", - "core_maths", - "font-types", + "font-types 0.10.1", +] + +[[package]] +name = "read-fonts" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709" +dependencies = [ + "bytemuck", + "font-types 0.12.4", + "once_cell", ] [[package]] @@ -2199,9 +2376,12 @@ checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce" [[package]] name = "roxmltree" -version = "0.20.0" +version = "0.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" +checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb" +dependencies = [ + "memchr", +] [[package]] name = "rustc-hash" @@ -2275,12 +2455,6 @@ dependencies = [ "tiny-skia", ] -[[package]] -name = "self_cell" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b12e76d157a900eb52e81bc6e9f3069344290341720e9178cde2407113ac8d89" - [[package]] name = "serde" version = "1.0.228" @@ -2308,7 +2482,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -2332,16 +2506,6 @@ dependencies = [ "quote", ] -[[package]] -name = "skrifa" -version = "0.37.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c31071dedf532758ecf3fed987cdb4bd9509f900e026ab684b4ecb81ea49841" -dependencies = [ - "bytemuck", - "read-fonts 0.35.0", -] - [[package]] name = "skrifa" version = "0.39.0" @@ -2352,6 +2516,16 @@ dependencies = [ "read-fonts 0.36.0", ] +[[package]] +name = "skrifa" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68" +dependencies = [ + "bytemuck", + "read-fonts 0.41.0", +] + [[package]] name = "slab" version = "0.4.11" @@ -2436,11 +2610,11 @@ checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" [[package]] name = "swash" -version = "0.2.6" +version = "0.2.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47846491253e976bdd07d0f9cc24b7daf24720d11309302ccbbc6e6b6e53550a" +checksum = "6c2499c2d826531388872b2268718aed907a39bd785ab0dcfe57fab26283f92e" dependencies = [ - "skrifa 0.37.0", + "skrifa 0.39.0", "yazi", "zeno", ] @@ -2457,12 +2631,25 @@ dependencies = [ ] [[package]] -name = "sys-locale" -version = "0.3.2" +name = "syn" +version = "3.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4" +checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9" dependencies = [ - "libc", + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.113", ] [[package]] @@ -2500,7 +2687,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -2511,7 +2698,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -2554,20 +2741,16 @@ dependencies = [ ] [[package]] -name = "tinyvec" -version = "1.10.0" +name = "tinystr" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643" dependencies = [ - "tinyvec_macros", + "displaydoc", + "serde_core", + "zerovec", ] -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - [[package]] name = "tokio" version = "1.49.0" @@ -2639,15 +2822,6 @@ name = "ttf-parser" version = "0.25.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" -dependencies = [ - "core_maths", -] - -[[package]] -name = "unicode-bidi" -version = "0.3.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" [[package]] name = "unicode-ident" @@ -2655,18 +2829,6 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" -[[package]] -name = "unicode-linebreak" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f" - -[[package]] -name = "unicode-script" -version = "0.5.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee" - [[package]] name = "unicode-segmentation" version = "1.12.0" @@ -2679,6 +2841,12 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + [[package]] name = "v_frame" version = "0.3.9" @@ -2760,7 +2928,7 @@ dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn", + "syn 2.0.113", "wasm-bindgen-shared", ] @@ -3120,7 +3288,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -3131,7 +3299,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", ] [[package]] @@ -3493,6 +3661,12 @@ dependencies = [ "wayland-protocols-wlr", ] +[[package]] +name = "writeable" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc" + [[package]] name = "x11-dl" version = "2.21.0" @@ -3568,6 +3742,40 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" +[[package]] +name = "yeslogic-fontconfig-sys" +version = "6.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d8b8abf912b9a29ff112e1671c97c33636903d13a69712037190e6805af4f76" +dependencies = [ + "dlib", + "once_cell", + "pkg-config", +] + +[[package]] +name = "yoke" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.113", + "synstructure", +] + [[package]] name = "zeno" version = "0.3.3" @@ -3591,7 +3799,63 @@ checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.113", +] + +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.113", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "zerovec" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8" +dependencies = [ + "serde", + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", ] [[package]] diff --git a/iris/Cargo.toml b/iris/Cargo.toml index 9c2276a..045fd80 100644 --- a/iris/Cargo.toml +++ b/iris/Cargo.toml @@ -8,8 +8,8 @@ edition.workspace = true [dependencies] iris-core = { workspace = true } iris-macro = { workspace = true } -cosmic-text = { workspace = true } -unicode-segmentation = { workspace = true } +parley = { workspace = true } +swash = { workspace = true } winit = { workspace = true } arboard = { workspace = true, features = ["wayland-data-control"] } pollster = { workspace = true } @@ -33,8 +33,8 @@ winit = "0.30.12" wgpu = "28.0.0" bytemuck = "1.23.1" image = "0.25.6" -cosmic-text = "0.16.0" -unicode-segmentation = "1.12.0" +parley = "0.11.1" +swash = "0.2.10" fxhash = "0.2.1" arboard = "3.6.1" iris-core = { path = "core" } diff --git a/iris/core/Cargo.toml b/iris/core/Cargo.toml index 71edca5..6002fd4 100644 --- a/iris/core/Cargo.toml +++ b/iris/core/Cargo.toml @@ -7,5 +7,6 @@ edition.workspace = true wgpu = { workspace = true } bytemuck ={ workspace = true } image = { workspace = true } -cosmic-text = { workspace = true } +parley = { workspace = true } +swash = { workspace = true } fxhash = { workspace = true } diff --git a/iris/core/src/lib.rs b/iris/core/src/lib.rs index 21882d9..1feb954 100644 --- a/iris/core/src/lib.rs +++ b/iris/core/src/lib.rs @@ -5,7 +5,6 @@ #![feature(unboxed_closures)] #![feature(fn_traits)] #![feature(const_destruct)] -#![feature(portable_simd)] #![feature(associated_type_defaults)] #![feature(unsize)] #![feature(coerce_unsized)] diff --git a/iris/core/src/primitive/color.rs b/iris/core/src/primitive/color.rs index fc27f1e..2afb7a2 100644 --- a/iris/core/src/primitive/color.rs +++ b/iris/core/src/primitive/color.rs @@ -10,6 +10,15 @@ pub struct Color { pub a: T, } +/// Required by parley's `Brush`, which every text style is generic over. Opaque +/// black rather than transparent: a brush that was never set should be visible +/// and obviously unstyled, not invisible. +impl Default for Color { + fn default() -> Self { + Self::BLACK + } +} + impl Color { pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN); pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX); diff --git a/iris/core/src/primitive/text.rs b/iris/core/src/primitive/text.rs index 820d1f0..cb14e5b 100644 --- a/iris/core/src/primitive/text.rs +++ b/iris/core/src/primitive/text.rs @@ -1,60 +1,68 @@ -use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2}; -use cosmic_text::{ - Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache, - SwashContent, +use crate::{Align, GlyphAtlas, GlyphKey, PlacedGlyph, RegionAlign, Textures, UiColor, util::Vec2}; +use parley::{ + Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout, + LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty, +}; +use swash::{ + FontRef, + scale::{Render, ScaleContext, Source, StrikeWith}, + zeno::{Format, Vector}, }; -use image::{DynamicImage, GenericImageView, RgbaImage}; -use std::simd::{Simd, num::SimdUint}; - -/// TODO: properly wrap this -pub mod text_lib { - pub use cosmic_text::*; -} +/// Everything text needs that outlives one string: the font collection, the +/// layout scratch space, the glyph rasteriser and the atlas they fill. pub struct TextData { - pub font_system: FontSystem, - pub swash_cache: SwashCache, - glyph_cache: Vec<(Placement, CacheKey, Color)>, + pub font_cx: FontContext, + pub layout_cx: LayoutContext, + scale_cx: ScaleContext, + pub atlas: GlyphAtlas, } impl Default for TextData { fn default() -> Self { Self { - font_system: FontSystem::new(), - swash_cache: SwashCache::new(), - glyph_cache: Default::default(), + font_cx: FontContext::new(), + layout_cx: LayoutContext::new(), + scale_cx: ScaleContext::new(), + atlas: GlyphAtlas::default(), } } } -#[derive(Clone, Copy)] +/// Which family to ask for. Kept as an owned name rather than parley's +/// borrowed `FontFamily<'_>` so that a widget can hold one without a lifetime. +#[derive(Clone, PartialEq)] +pub enum Family { + SansSerif, + Serif, + Monospace, + Named(String), +} + +impl Family { + fn family(&self) -> FontFamily<'_> { + let name = match self { + Self::SansSerif => FontFamilyName::Generic(GenericFamily::SansSerif), + Self::Serif => FontFamilyName::Generic(GenericFamily::Serif), + Self::Monospace => FontFamilyName::Generic(GenericFamily::Monospace), + Self::Named(name) => FontFamilyName::Named(name.as_str().into()), + }; + FontFamily::Single(name) + } +} + +#[derive(Clone, PartialEq)] pub struct TextAttrs { pub color: UiColor, pub font_size: f32, pub line_height: f32, - pub family: Family<'static>, + pub family: Family, pub wrap: bool, /// inner alignment of text region (within where it's drawn) pub align: RegionAlign, } -impl TextAttrs { - pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option) { - buf.set_metrics_and_size( - font_system, - Metrics::new(self.font_size, self.line_height), - width, - None, - ); - let attrs = Attrs::new().family(self.family); - let list = AttrsList::new(&attrs); - for line in &mut buf.lines { - line.set_attrs_list(list.clone()); - } - } -} - -pub type TextBuffer = Buffer; +pub const LINE_HEIGHT_MULT: f32 = 1.1; impl Default for TextAttrs { fn default() -> Self { @@ -70,122 +78,200 @@ impl Default for TextAttrs { } } -pub const LINE_HEIGHT_MULT: f32 = 1.1; +/// A string together with its laid-out form. +/// +/// The text and the layout live in one place because parley's `Layout` borrows +/// nothing but is only meaningful against the string it was built from: keeping +/// them apart is how they get out of step. +pub struct TextBuffer { + text: String, + layout: Layout, + /// What the current layout was built for, so `shape` can decline to redo + /// work that would come out the same. + shaped: Option<(TextAttrs, Option)>, +} -impl TextData { - pub fn draw( - &mut self, - buffer: &mut TextBuffer, - attrs: &TextAttrs, - textures: &mut Textures, - ) -> RenderedText { - // TODO: either this or the layout stuff (or both) is super slow, - // should probably do texture packing and things if possible. - // very visible if you add just a couple of wrapping texts and resize window - // should also be timed to figure out exactly what points need to be sped up - // let mut pixels = HashMap::<_, [u8; 4]>::default(); - let mut min_x = 0; - let mut min_y = 0; - let mut max_x = 0; - let mut max_y = 0; - let text_color = { - let c = attrs.color; - cosmic_text::Color::rgba(c.r, c.g, c.b, c.a) - }; - let mut max_width = 0.0f32; - let mut height = 0.0; - - for run in buffer.layout_runs() { - for glyph in run.glyphs.iter() { - let physical_glyph = glyph.physical((0., 0.), 1.0); - - let glyph_color = match glyph.color_opt { - Some(some) => some, - None => text_color, - }; - - if let Some(img) = self - .swash_cache - .get_image(&mut self.font_system, physical_glyph.cache_key) - { - let mut pos = img.placement; - pos.left += physical_glyph.x; - pos.top = physical_glyph.y + run.line_y as i32 - pos.top; - min_x = min_x.min(pos.left); - min_y = min_y.min(pos.top); - max_x = max_x.max(pos.left + pos.width as i32); - max_y = max_y.max(pos.top + pos.height as i32); - self.glyph_cache - .push((pos, physical_glyph.cache_key, glyph_color)); - } - } - max_width = max_width.max(run.line_w); - height += run.line_height; +impl TextBuffer { + pub fn new(text: impl Into) -> Self { + Self { + text: text.into(), + layout: Layout::new(), + shaped: None, } - let img_width = (max_x - min_x + 1) as u32; - let img_height = (max_y - min_y + 1) as u32; - let mut image = RgbaImage::new(img_width, img_height); + } - for (pos, key, color) in self.glyph_cache.drain(..) { - let img = self - .swash_cache - .get_image(&mut self.font_system, key) - .as_ref() - .unwrap(); - let mut merge = |i, color: [u8; 4]| { - let i = i as i32; - let x = (i % pos.width as i32 + pos.left - min_x) as u32; - let y = (i / pos.width as i32 + pos.top - min_y) as u32; - let pixel = &mut image[(x, y)].0; - // TODO: no clue if proper alpha blending should be done - *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into(); - }; + pub fn new_empty() -> Self { + Self::new("") + } - match img.content { - SwashContent::Mask => { - for (i, a) in img.data.iter().enumerate() { - let mut color = color.as_rgba(); - color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8; - merge(i, color); - } - } - SwashContent::SubpixelMask => todo!("subpixel mask text rendering"), - SwashContent::Color => { - let (colors, _) = img.data.as_chunks::<4>(); - for (i, color) in colors.iter().enumerate() { - merge(i, *color); - } - } - } + pub fn text(&self) -> &str { + &self.text + } + + pub fn layout(&self) -> &Layout { + &self.layout + } + + pub fn is_empty(&self) -> bool { + self.text.is_empty() + } + + pub fn set_text(&mut self, text: impl Into) { + let text = text.into(); + if text != self.text { + self.text = text; + self.shaped = None; } + } - let max_dim = 8192; - if image.width() > max_dim || image.height() > max_dim { - let width = image.width().min(max_dim); - let height = image.height().min(max_dim); - eprintln!( - "WARNING: image of size {:?} cropped to {:?} (texture too big)", - image.dimensions(), - (width, height) - ); - image = image.view(0, 0, width, height).to_image(); - } + /// Edit the string in place; invalidates the layout unconditionally, since + /// the caller is assumed to have changed something. + pub fn edit(&mut self) -> &mut String { + self.shaped = None; + &mut self.text + } - RenderedText { - handle: textures.add(image), - top_left_offset: Vec2::new(min_x as f32, min_y as f32), - size: Vec2::new(max_width, height), + pub fn size(&self) -> Vec2 { + Vec2::new(self.layout.width(), self.layout.height()) + } + + /// Lay the text out, unless it is already laid out for these attributes and + /// this width. + pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option) { + if self.shaped.as_ref() == Some(&(attrs.clone(), width)) { + return; } + let mut builder = data + .layout_cx + .ranged_builder(&mut data.font_cx, &self.text, 1.0, true); + builder.push_default(StyleProperty::FontFamily(attrs.family.family())); + builder.push_default(StyleProperty::FontSize(attrs.font_size)); + builder.push_default(StyleProperty::LineHeight(LineHeight::Absolute( + attrs.line_height, + ))); + builder.push_default(StyleProperty::Brush(attrs.color)); + builder.build_into(&mut self.layout, &self.text); + self.layout.break_all_lines(width); + self.layout + .align(Alignment::Start, AlignmentOptions::default()); + self.shaped = Some((attrs.clone(), width)); } } -#[derive(Clone)] -pub struct RenderedText { - pub handle: TextureHandle, - pub top_left_offset: Vec2, - pub size: Vec2, +impl TextData { + /// Rasterise whatever of `buffer` is not in the atlas yet, and return where + /// each glyph goes relative to the text's top-left. + /// + /// Nothing is uploaded for a glyph already in the atlas, which is the point + /// of having one: a resize re-runs this and touches the GPU only if the new + /// width brought genuinely new glyphs into view. + pub fn place(&mut self, buffer: &TextBuffer, textures: &mut Textures) -> Vec { + let mut placed = Vec::new(); + for line in buffer.layout.lines() { + for item in line.items() { + let PositionedLayoutItem::GlyphRun(run) = item else { + continue; + }; + let font = run.run().font(); + let font_size = run.run().font_size(); + let coords = run.run().normalized_coords(); + let Some(font_ref) = FontRef::from_index(font.data.as_ref(), font.index as usize) + else { + continue; + }; + let coords_hash = hash_coords(coords); + // `font.data.id()` rather than the pointer, so the same font + // loaded twice is still one set of entries. + let font_id = font.data.id(); + + for glyph in run.positioned_glyphs() { + let subpixel = ((glyph.x.fract() * 4.0).round() as i32).rem_euclid(4) as u8; + let key = GlyphKey { + font: font_id, + glyph: glyph.id, + size: (font_size * 16.0).round() as u32, + subpixel, + coords: coords_hash, + }; + let entry = match self.atlas.get(&key) { + Some(entry) => entry, + None => { + let mut scaler = self + .scale_cx + .builder(font_ref) + .size(font_size) + .hint(true) + .normalized_coords(coords) + .build(); + let image = Render::new(&[ + Source::ColorOutline(0), + Source::ColorBitmap(StrikeWith::BestFit), + Source::Outline, + ]) + .format(Format::Alpha) + .offset(Vector::new(subpixel as f32 / 4.0, 0.0)) + .render(&mut scaler, glyph.id as u16); + match image { + Some(image) => self.atlas.insert(key, &image, textures), + None => { + self.atlas.insert_empty(key); + None + } + } + } + }; + let Some(entry) = entry else { continue }; + placed.push(PlacedGlyph { + entry, + offset: Vec2::new( + glyph.x.floor() + entry.left as f32, + glyph.y.floor() - entry.top as f32, + ), + }); + } + } + } + placed + } } -pub trait HasTextures { - fn add_texture(&mut self, image: DynamicImage) -> TextureHandle; +fn hash_coords(coords: &[i16]) -> u64 { + // FxHash over the coordinates; they are short and change rarely. + let mut h: u64 = 0xcbf2_9ce4_8422_2325; + for c in coords { + h ^= *c as u16 as u64; + h = h.wrapping_mul(0x1000_0000_01b3); + } + h +} + +/// A laid-out string, ready to draw: where each glyph goes, how big the whole +/// thing is, and what colour to tint the atlas with. +/// +/// Cheap to clone and to keep, which is the point -- a widget holds one across +/// frames and re-emits its quads without going near the rasteriser. +#[derive(Clone)] +pub struct RenderedText { + pub glyphs: std::sync::Arc>, + pub size: Vec2, + pub color: UiColor, +} + +impl TextData { + /// Lay out and place in one step, which is what a widget wants. + pub fn render( + &mut self, + buffer: &mut TextBuffer, + attrs: &TextAttrs, + width: Option, + textures: &mut Textures, + ) -> RenderedText { + buffer.shape(self, attrs, width); + let glyphs = self.place(buffer, textures); + RenderedText { + glyphs: std::sync::Arc::new(glyphs), + size: buffer.size(), + color: attrs.color, + } + } } diff --git a/iris/core/src/primitive/texture.rs b/iris/core/src/primitive/texture.rs index 74e3bf0..4fec782 100644 --- a/iris/core/src/primitive/texture.rs +++ b/iris/core/src/primitive/texture.rs @@ -29,14 +29,27 @@ pub struct Textures { pub enum TextureUpdate<'a> { Push(&'a DynamicImage), Set(u32, &'a DynamicImage), + /// Overwrite a rectangle of an existing texture, rather than replacing it. + /// The glyph atlas grows a glyph at a time, and re-uploading a whole atlas + /// per glyph is megabytes of copy for a few hundred bytes of change. + Patch(u32, PatchRect, &'a DynamicImage), Free(u32), PushFree, SetFree, } +#[derive(Debug, Clone, Copy)] +pub struct PatchRect { + pub x: u32, + pub y: u32, + pub width: u32, + pub height: u32, +} + enum Update { Push(u32), Set(u32), + Patch(u32, PatchRect), Free(u32), } @@ -81,6 +94,19 @@ impl Textures { } } + /// The stored image for a handle, to be written into before `patch`. + pub fn image_mut(&mut self, handle: &TextureHandle) -> &mut DynamicImage { + self.images[handle.inner.view_idx as usize] + .as_mut() + .expect("texture was freed while still held") + } + + /// Queue an upload of just `rect`, after writing it with `image_mut`. + pub fn patch(&mut self, handle: &TextureHandle, rect: PatchRect) { + self.updates + .push(Update::Patch(handle.inner.view_idx, rect)); + } + pub fn free(&mut self) { for idx in self.recv.try_iter() { self.images[idx as usize] = None; @@ -99,6 +125,10 @@ impl Textures { .as_ref() .map(|img| TextureUpdate::Set(i, img)) .unwrap_or(TextureUpdate::SetFree), + Update::Patch(i, rect) => self.images[i as usize] + .as_ref() + .map(|img| TextureUpdate::Patch(i, rect, img)) + .unwrap_or(TextureUpdate::SetFree), Update::Free(i) => TextureUpdate::Free(i), }) } diff --git a/iris/core/src/render/atlas.rs b/iris/core/src/render/atlas.rs new file mode 100644 index 0000000..a85d9ac --- /dev/null +++ b/iris/core/src/render/atlas.rs @@ -0,0 +1,234 @@ +//! A glyph atlas: one texture holding many rasterised glyphs, so drawing text +//! is a quad per glyph rather than a texture per string. +//! +//! What this replaces is why it exists. Text used to be rasterised into its own +//! `RgbaImage` and uploaded as a whole texture, per text widget, every time +//! anything about it changed -- so every window resize re-rasterised and +//! re-uploaded every visible string, which is what the TODO meant by "resizing +//! (per frame) is really slow". Here a glyph is rasterised once for a given +//! font, size and subpixel offset and then reused by every string that contains +//! it, and a resize re-emits quads without touching the GPU's copy at all. + +use crate::{ + PatchRect, TextureHandle, Textures, + util::{HashMap, Vec2}, +}; +use image::RgbaImage; +use swash::scale::image::{Content, Image}; + +/// Side of one atlas page, in pixels. 1024 is 4 MB at RGBA8 -- enough for a +/// few thousand glyphs at UI sizes, and small enough that a page nobody fills +/// is not a big waste. +const PAGE: u32 = 1024; + +/// Transparent margin kept around every glyph, so that sampling one cannot +/// pick up its neighbour along a shared edge. +const PAD: u32 = 1; + +/// Identifies a rasterised glyph. Anything that changes the pixels has to be in +/// here, or two different glyphs share one entry and the wrong one is drawn. +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +pub struct GlyphKey { + pub font: u64, + pub glyph: u32, + /// Font size in 1/16 px, so sizes that round to the same pixels share a + /// raster instead of filling the atlas with near-duplicates. + pub size: u32, + /// Horizontal subpixel phase, in 1/4 px. + pub subpixel: u8, + /// Hash of the variation coordinates; a variable font at two weights is two + /// different sets of pixels from one glyph id. + pub coords: u64, +} + +#[derive(Clone, Copy)] +pub struct GlyphEntry { + pub uv_min: [f32; 2], + pub uv_max: [f32; 2], + /// Offset from the glyph's pen position to the top-left of its pixels. + pub left: i32, + pub top: i32, + pub width: u32, + pub height: u32, + pub is_color: bool, + pub view_idx: u32, + pub sampler_idx: u32, +} + +struct Page { + handle: TextureHandle, + /// Shelf packing: glyphs are placed left to right along a shelf whose + /// height is the tallest glyph on it, and a new shelf starts above when the + /// row runs out. Chosen over a real packer because glyphs at one size are + /// close to the same height, which is the case shelves are good at. + x: u32, + y: u32, + shelf_height: u32, +} + +#[derive(Default)] +pub struct GlyphAtlas { + pages: Vec, + /// `None` for a glyph that rasterised to nothing -- a space, say. Cached + /// too, so it is not re-rasterised on every layout. + entries: HashMap>, +} + +impl GlyphAtlas { + pub fn get(&self, key: &GlyphKey) -> Option> { + self.entries.get(key).copied() + } + + /// Rasterised pixels in, a place in the atlas out. `None` means the glyph + /// has no pixels, which is a normal answer rather than a failure. + pub fn insert( + &mut self, + key: GlyphKey, + image: &Image, + textures: &mut Textures, + ) -> Option { + let w = image.placement.width; + let h = image.placement.height; + if w == 0 || h == 0 { + self.entries.insert(key, None); + return None; + } + if w + PAD * 2 > PAGE || h + PAD * 2 > PAGE { + // A single glyph larger than a page. Refusing is better than + // silently drawing a cropped one; the caller draws nothing. + self.entries.insert(key, None); + return None; + } + + let (page_idx, x, y) = self.allocate(w, h, textures); + let page = &self.pages[page_idx]; + + let img = textures.image_mut(&page.handle); + let rgba = img.as_mut_rgba8().expect("atlas page is rgba8"); + write_glyph(rgba, image, x, y); + + let handle = page.handle.clone(); + let rect = PatchRect { + x, + y, + width: w, + height: h, + }; + textures.patch(&handle, rect); + + let page = &self.pages[page_idx]; + let scale = 1.0 / PAGE as f32; + let entry = GlyphEntry { + uv_min: [x as f32 * scale, y as f32 * scale], + uv_max: [(x + w) as f32 * scale, (y + h) as f32 * scale], + left: image.placement.left, + top: image.placement.top, + width: w, + height: h, + is_color: matches!(image.content, Content::Color), + view_idx: page.handle.primitive().view_idx, + sampler_idx: page.handle.primitive().sampler_idx, + }; + self.entries.insert(key, Some(entry)); + Some(entry) + } + + /// A free `w`x`h` spot, opening a shelf or a page as needed. + fn allocate(&mut self, w: u32, h: u32, textures: &mut Textures) -> (usize, u32, u32) { + let need_w = w + PAD; + let need_h = h + PAD; + if let Some(i) = self.pages.iter().position(|p| fits(p, need_w, need_h)) { + let page = &mut self.pages[i]; + if page.x + need_w > PAGE { + page.y += page.shelf_height; + page.x = PAD; + page.shelf_height = 0; + } + let (x, y) = (page.x, page.y); + page.x += need_w; + page.shelf_height = page.shelf_height.max(need_h); + return (i, x, y); + } + + let handle = textures.add(RgbaImage::new(PAGE, PAGE)); + self.pages.push(Page { + handle, + x: PAD + w + PAD, + y: PAD, + shelf_height: h + PAD, + }); + (self.pages.len() - 1, PAD, PAD) + } + + /// Record that a glyph has no pixels, so it is not re-rasterised. + pub fn insert_empty(&mut self, key: GlyphKey) { + self.entries.insert(key, None); + } + + pub fn page_count(&self) -> usize { + self.pages.len() + } + + pub fn glyph_count(&self) -> usize { + self.entries.len() + } +} + +fn fits(page: &Page, need_w: u32, need_h: u32) -> bool { + // On the current shelf, or on a new one above it. + (page.x + need_w <= PAGE && page.y + need_h <= PAGE) + || (need_w + PAD <= PAGE && page.y + page.shelf_height + need_h <= PAGE) +} + +/// Copy one rasterised glyph into the page image at `(x, y)`. +/// +/// A mask glyph keeps its coverage in alpha with the colour left to the shader, +/// so one raster serves text of any colour; a colour glyph carries its own. +fn write_glyph(page: &mut RgbaImage, image: &Image, x: u32, y: u32) { + let w = image.placement.width; + let h = image.placement.height; + match image.content { + Content::Mask => { + for row in 0..h { + for col in 0..w { + let a = image.data[(row * w + col) as usize]; + page.put_pixel(x + col, y + row, image::Rgba([255, 255, 255, a])); + } + } + } + Content::Color => { + for row in 0..h { + for col in 0..w { + let i = ((row * w + col) * 4) as usize; + let px = [ + image.data[i], + image.data[i + 1], + image.data[i + 2], + image.data[i + 3], + ]; + page.put_pixel(x + col, y + row, image::Rgba(px)); + } + } + } + Content::SubpixelMask => { + // Not asked for: `Format::Alpha` is what the renderer requests, so + // reaching here means the request changed and this needs writing. + // Drawn as a plain mask from the green channel rather than dropped, + // so the text is readable rather than absent. + for row in 0..h { + for col in 0..w { + let i = ((row * w + col) * 4) as usize; + let a = image.data[i + 1]; + page.put_pixel(x + col, y + row, image::Rgba([255, 255, 255, a])); + } + } + } + } +} + +/// Where a glyph goes on screen, in pixels relative to the text's origin. +#[derive(Clone, Copy)] +pub struct PlacedGlyph { + pub entry: GlyphEntry, + pub offset: Vec2, +} diff --git a/iris/core/src/render/mod.rs b/iris/core/src/render/mod.rs index 0489ab5..e298230 100644 --- a/iris/core/src/render/mod.rs +++ b/iris/core/src/render/mod.rs @@ -11,11 +11,13 @@ use wgpu::{ *, }; +mod atlas; mod data; mod primitive; mod texture; mod util; +pub use atlas::*; pub use data::{Mask, MaskIdx}; pub use primitive::*; diff --git a/iris/core/src/render/primitive.rs b/iris/core/src/render/primitive.rs index f8f1069..b79a0e6 100644 --- a/iris/core/src/render/primitive.rs +++ b/iris/core/src/render/primitive.rs @@ -93,7 +93,13 @@ macro_rules! primitives { } )* }; - (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t),+) }; + // The recursion has to hand back the same shape it matches -- space + // separated, not comma separated. Written with `$($t),+` it re-entered + // with a comma as the first token and never terminated, which happened to + // work only because there were exactly two primitives: the first step left + // a single token, and a single token matches the base case whichever + // separator it was written with. + (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t)+) }; (@count $t:tt) => { 1 }; } @@ -201,6 +207,7 @@ impl PrimitiveHandle { primitives!( rects: RectPrimitive => 0, textures: TexturePrimitive => 1, + glyphs: GlyphPrimitive => 2, ); #[repr(C)] @@ -230,6 +237,28 @@ pub struct TexturePrimitive { pub sampler_idx: u32, } +/// One glyph, drawn as a sub-rectangle of the glyph atlas. +/// +/// Separate from `TexturePrimitive` because that one samples a whole texture: +/// text needs many quads sharing one atlas, which is the whole point of having +/// an atlas. `color` is the text colour and is multiplied by the atlas's alpha +/// for an ordinary mask glyph; a colour glyph (emoji) carries its own colour +/// and takes the atlas texel unchanged, which is what `IS_COLOR` selects. +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct GlyphPrimitive { + pub uv_min: [f32; 2], + pub uv_max: [f32; 2], + pub view_idx: u32, + pub sampler_idx: u32, + pub color: Color, + pub flags: u32, +} + +impl GlyphPrimitive { + pub const IS_COLOR: u32 = 1; +} + pub struct PrimitiveVec { vec: Vec, free: Vec, diff --git a/iris/core/src/render/shader.wgsl b/iris/core/src/render/shader.wgsl index 197d101..1e6df68 100644 --- a/iris/core/src/render/shader.wgsl +++ b/iris/core/src/render/shader.wgsl @@ -1,5 +1,6 @@ const RECT: u32 = 0u; const TEXTURE: u32 = 1u; +const GLYPH: u32 = 2u; @group(0) @binding(0) var window: WindowUniform; @@ -7,6 +8,8 @@ var window: WindowUniform; var rects: array; @group(1) @binding(TEXTURE) var textures: array; +@group(1) @binding(GLYPH) +var glyphs: array; struct Rect { color: u32, @@ -20,6 +23,15 @@ struct TextureInfo { sampler_idx: u32, } +struct GlyphInfo { + uv_min: vec2, + uv_max: vec2, + view_idx: u32, + sampler_idx: u32, + color: u32, + flags: u32, +} + struct Mask { x: UiSpan, y: UiSpan, @@ -125,6 +137,9 @@ fn fs_main( case TEXTURE: { color = draw_texture(region, textures[i]); } + case GLYPH: { + color = draw_glyph(region, glyphs[i]); + } default: { color = vec4(1.0, 0.0, 1.0, 1.0); } @@ -148,6 +163,17 @@ fn draw_texture(region: Region, info: TextureInfo) -> vec4 { return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv); } +fn draw_glyph(region: Region, g: GlyphInfo) -> vec4 { + let uv = mix(g.uv_min, g.uv_max, region.uv); + let texel = textureSample(views[g.view_idx], samplers[g.sampler_idx], uv); + if (g.flags & 1u) != 0u { + return texel; + } + var color = unpack4x8unorm(g.color); + color.a *= texel.a; + return color; +} + fn draw_rounded_rect(region: Region, rect: Rect) -> vec4 { var color = unpack4x8unorm(rect.color); diff --git a/iris/core/src/render/texture.rs b/iris/core/src/render/texture.rs index a9ec637..5c44ef0 100644 --- a/iris/core/src/render/texture.rs +++ b/iris/core/src/render/texture.rs @@ -1,11 +1,15 @@ -use image::{DynamicImage, EncodableLayout}; +use image::{DynamicImage, EncodableLayout, GenericImageView}; use wgpu::{util::DeviceExt, *}; -use crate::{TextureUpdate, Textures}; +use crate::{PatchRect, TextureUpdate, Textures}; pub struct GpuTextures { device: Device, queue: Queue, + /// Kept alongside the views because a patch writes into the texture, and a + /// view cannot be written through. Parallel to `views`; `None` where the + /// slot is the shared null view. + textures: Vec>, views: Vec, view_count: usize, samplers: Vec, @@ -21,6 +25,13 @@ impl GpuTextures { match update { TextureUpdate::Push(image) => self.push(image), TextureUpdate::Set(i, image) => self.set(i, image), + TextureUpdate::Patch(i, rect, image) => { + // A patch changes texture contents, not the binding array, + // so it must not report `changed` -- rebuilding the bind + // group per glyph is the cost this exists to avoid. + self.patch(i, rect, image); + changed = false; + } TextureUpdate::SetFree => self.view_count += 1, TextureUpdate::Free(i) => self.free(i), TextureUpdate::PushFree => self.push_free(), @@ -30,24 +41,66 @@ impl GpuTextures { } fn set(&mut self, i: u32, image: &DynamicImage) { self.view_count += 1; - let view = self.create_view(image); + let (texture, view) = self.create(image); + self.textures[i as usize] = Some(texture); self.views[i as usize] = view; } fn free(&mut self, i: u32) { self.view_count -= 1; + self.textures[i as usize] = None; self.views[i as usize] = self.null_view.clone(); } fn push(&mut self, image: &DynamicImage) { self.view_count += 1; - let view = self.create_view(image); + let (texture, view) = self.create(image); + self.textures.push(Some(texture)); self.views.push(view); } fn push_free(&mut self) { self.view_count += 1; + self.textures.push(None); self.views.push(self.null_view.clone()); } - fn create_view(&self, image: &DynamicImage) -> TextureView { + fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) { + let Some(texture) = &self.textures[i as usize] else { + return; + }; + if rect.width == 0 || rect.height == 0 { + return; + } + // Cropped rather than written straight from the atlas, because + // write_texture wants tightly packed rows and the atlas rows are as + // wide as the atlas. A glyph is small, so the copy is too. + let sub = image + .view(rect.x, rect.y, rect.width, rect.height) + .to_image(); + self.queue.write_texture( + TexelCopyTextureInfo { + texture, + mip_level: 0, + origin: Origin3d { + x: rect.x, + y: rect.y, + z: 0, + }, + aspect: TextureAspect::All, + }, + sub.as_bytes(), + TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(rect.width * 4), + rows_per_image: Some(rect.height), + }, + Extent3d { + width: rect.width, + height: rect.height, + depth_or_array_layers: 1, + }, + ); + } + + fn create(&self, image: &DynamicImage) -> (Texture, TextureView) { let image = image.to_rgba8(); let (width, height) = image.dimensions(); let texture = self.device.create_texture_with_data( @@ -63,13 +116,14 @@ impl GpuTextures { sample_count: 1, dimension: TextureDimension::D2, format: TextureFormat::Rgba8Unorm, - usage: TextureUsages::TEXTURE_BINDING, + usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST, view_formats: &[], }, wgt::TextureDataOrder::MipMajor, image.as_bytes(), ); - texture.create_view(&TextureViewDescriptor::default()) + let view = texture.create_view(&TextureViewDescriptor::default()); + (texture, view) } pub fn new(device: &Device, queue: &Queue) -> Self { @@ -77,6 +131,7 @@ impl GpuTextures { Self { device: device.clone(), queue: queue.clone(), + textures: Vec::new(), views: Vec::new(), samplers: vec![default_sampler(device)], no_views: vec![null_view.clone()], diff --git a/iris/core/src/ui/painter.rs b/iris/core/src/ui/painter.rs index f7f4939..380a819 100644 --- a/iris/core/src/ui/painter.rs +++ b/iris/core/src/ui/painter.rs @@ -1,7 +1,7 @@ use crate::{ Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData, - TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId, - render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst}, + TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Widget, WidgetId, + render::{GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst}, util::Vec2, }; @@ -90,10 +90,48 @@ impl<'a> Painter<'a> { self.primitive_at(handle.primitive(), region); } - /// returns (handle, offset from top left) - pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText { + pub fn render_text( + &mut self, + buffer: &mut TextBuffer, + attrs: &TextAttrs, + width: Option, + ) -> RenderedText { let ui = self.rsc.ui_mut(); - ui.text.draw(buffer, attrs, &mut ui.textures) + ui.text.render(buffer, attrs, width, &mut ui.textures) + } + + /// Draw a laid-out string: one quad per glyph, all sampling the atlas. + /// + /// `origin` is where the text's top-left goes; every glyph is placed at an + /// absolute pixel offset from it, so re-drawing after a resize is this loop + /// and nothing else. + pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) { + let flags_for = |is_color| { + if is_color { + GlyphPrimitive::IS_COLOR + } else { + 0 + } + }; + for glyph in text.glyphs.iter() { + let mut region = origin; + region.x.end = region.x.start; + region.y.end = region.y.start; + let mut region = region.offset(UiVec2::abs(glyph.offset)); + region.x.end = region.x.start + UiScalar::abs(glyph.entry.width as f32); + region.y.end = region.y.start + UiScalar::abs(glyph.entry.height as f32); + self.primitive_at( + GlyphPrimitive { + uv_min: glyph.entry.uv_min, + uv_max: glyph.entry.uv_max, + view_idx: glyph.entry.view_idx, + sampler_idx: glyph.entry.sampler_idx, + color: text.color, + flags: flags_for(glyph.entry.is_color), + }, + region, + ); + } } pub fn region(&self) -> UiRegion { diff --git a/iris/core/src/ui/size.rs b/iris/core/src/ui/size.rs index 6f82492..a874cf9 100644 --- a/iris/core/src/ui/size.rs +++ b/iris/core/src/ui/size.rs @@ -76,8 +76,13 @@ impl SizeCtx<'_> { self.output_size } - pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText { - self.text.draw(buffer, attrs, self.textures) + pub fn draw_text( + &mut self, + buffer: &mut TextBuffer, + attrs: &TextAttrs, + width: Option, + ) -> RenderedText { + self.text.render(buffer, attrs, width, self.textures) } pub fn label(&self, id: WidgetId) -> &String { diff --git a/iris/examples/tabs/main.rs b/iris/examples/tabs/main.rs index d9789f1..6316924 100644 --- a/iris/examples/tabs/main.rs +++ b/iris/examples/tabs/main.rs @@ -1,4 +1,3 @@ -use cosmic_text::Family; use std::{cell::RefCell, rc::Rc}; use winit::event::WindowEvent; diff --git a/iris/src/lib.rs b/iris/src/lib.rs index fa54bba..05ef101 100644 --- a/iris/src/lib.rs +++ b/iris/src/lib.rs @@ -1,6 +1,5 @@ #![feature(unboxed_closures)] #![feature(fn_traits)] -#![feature(gen_blocks)] #![feature(associated_type_defaults)] #![feature(unsize)] #![feature(option_into_flat_iter)] diff --git a/iris/src/widget/text/build.rs b/iris/src/widget/text/build.rs index a2e8134..1619bfe 100644 --- a/iris/src/widget/text/build.rs +++ b/iris/src/widget/text/build.rs @@ -1,5 +1,4 @@ use crate::prelude::*; -use cosmic_text::{Attrs, Family, Metrics}; use std::marker::{PhantomData, Sized}; pub struct TextBuilder = ()> { @@ -20,7 +19,7 @@ impl> TextBuilder { self.attrs.color = color; self } - pub fn family(mut self, family: Family<'static>) -> Self { + pub fn family(mut self, family: Family) -> Self { self.attrs.family = family; self } @@ -82,19 +81,13 @@ impl TextBuilderOutput for TextOutput { state: &mut Rsc, builder: TextBuilder, ) -> Self::Output { - let mut buf = TextBuffer::new_empty(Metrics::new( - builder.attrs.font_size, - builder.attrs.line_height, - )); + let buf = TextBuffer::new(&builder.content); let hint = builder.hint.get(state); - let font_system = &mut state.ui_mut().text.font_system; - buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None); let mut text = Text { content: builder.content.into(), view: TextView::new(buf, builder.attrs, hint), }; text.content.changed = false; - builder.attrs.apply(font_system, &mut text.view.buf, None); text } } @@ -110,19 +103,11 @@ impl TextBuilderOutput for TextEditOutput { state: &mut State, builder: TextBuilder, ) -> Self::Output { - let buf = TextBuffer::new_empty(Metrics::new( - builder.attrs.font_size, - builder.attrs.line_height, - )); - let mut text = TextEdit::new( + let buf = TextBuffer::new(&builder.content); + TextEdit::new( TextView::new(buf, builder.attrs, builder.hint.get(state)), builder.output.mode, - ); - let font_system = &mut state.ui_mut().text.font_system; - text.buf - .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None); - builder.attrs.apply(font_system, &mut text.buf, None); - text + ) } } diff --git a/iris/src/widget/text/edit.rs b/iris/src/widget/text/edit.rs index 846d16e..90f6eea 100644 --- a/iris/src/widget/text/edit.rs +++ b/iris/src/widget/text/edit.rs @@ -1,17 +1,35 @@ use crate::prelude::*; -use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion}; +use iris_core::{TextData, UiColor}; +use parley::{Affinity, Layout, Selection}; use std::ops::{Deref, DerefMut}; -use unicode_segmentation::UnicodeSegmentation; use winit::{ event::KeyEvent, keyboard::{Key, NamedKey}, }; +/// Which way a cursor movement goes. Named here rather than taken from the text +/// stack so that the key handling below does not have to change when the stack +/// does; the mapping onto parley lives in one place, in `apply_motion`. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Motion { + Left, + Right, + LeftWord, + RightWord, + Up, + Down, + LineStart, + LineEnd, +} + pub struct TextEdit { view: TextView, - selection: TextSelection, - history: Vec<(String, TextSelection)>, - double_hit: Option, + /// `None` when the field is not focused -- which parley's `Selection` has no + /// way to say, since it always denotes some position in the text. A + /// collapsed selection is a caret; an uncollapsed one is a span. + selection: Option, + history: Vec<(String, Option)>, + double_hit: Option, pub mode: EditMode, } @@ -25,27 +43,19 @@ impl TextEdit { pub fn new(view: TextView, mode: EditMode) -> Self { Self { view, - selection: Default::default(), + selection: None, history: Default::default(), double_hit: None, mode, } } - pub fn select_content(&self, start: Cursor, end: Cursor) -> String { - let (start, end) = sort_cursors(start, end); - let mut iter = self.buf.lines.iter().skip(start.line); - let first = iter.next().unwrap(); - if start.line == end.line { - first.text()[start.index..end.index].to_string() - } else { - let mut str = first.text()[start.index..].to_string(); - for _ in (start.line + 1)..end.line { - str = str + "\n" + iter.next().unwrap().text(); - } - let last = iter.next().unwrap(); - str = str + "\n" + &last.text()[..end.index]; - str + + pub fn selected_text(&self) -> Option { + let sel = self.selection?; + if sel.is_collapsed() { + return None; } + Some(self.buf.text()[sel.text_range()].to_string()) } } @@ -57,39 +67,29 @@ impl Widget for TextEdit { painter.layer = base; let region = self.region(); - let size = vec2(1, self.attrs.line_height); - match self.selection { - TextSelection::None => (), - TextSelection::Pos(cursor) => { - if let Some(offset) = cursor_pos(cursor, &self.buf) { - painter.primitive_within( - RectPrimitive::color(Color::WHITE), - size.align(Align::TOP_LEFT).offset(offset).within(®ion), - ); - } - } - TextSelection::Span { start, end } => { - let (start, end) = sort_cursors(start, end); - for (l, x, width) in iter_layout_lines(start, end, &self.buf) { - let top_left = vec2(x, self.attrs.line_height * l as f32); - painter.primitive_within( - RectPrimitive::color(Color::SKY), - size.with_x(width) - .align(Align::TOP_LEFT) - .offset(top_left) - .within(®ion), - ); - } - if let Some(end_offset) = cursor_pos(end, &self.buf) { - painter.primitive_within( - RectPrimitive::color(Color::WHITE), - size.align(Align::TOP_LEFT) - .offset(end_offset) - .within(®ion), - ); - } - } + let Some(selection) = self.selection else { + return; + }; + let layout = self.view.buf.layout(); + + // parley reports selection as boxes in layout space, so bidi and + // wrapped lines come out right without this code knowing about either. + for (rect, _) in selection.geometry(layout) { + let size = vec2(rect.width() as f32, rect.height() as f32); + let top_left = vec2(rect.x0 as f32, rect.y0 as f32); + painter.primitive_within( + RectPrimitive::color(Color::SKY), + size.align(Align::TOP_LEFT).offset(top_left).within(®ion), + ); } + + let caret = selection.focus().geometry(layout, CARET_WIDTH); + let size = vec2(caret.width() as f32, caret.height() as f32); + let top_left = vec2(caret.x0 as f32, caret.y0 as f32); + painter.primitive_within( + RectPrimitive::color(Color::WHITE), + size.align(Align::TOP_LEFT).offset(top_left).within(®ion), + ); } fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { @@ -101,154 +101,79 @@ impl Widget for TextEdit { } } -/// provides top left + width -fn iter_layout_lines( - start: Cursor, - end: Cursor, - buf: &TextBuffer, -) -> impl Iterator { - gen move { - let mut iter = buf.layout_runs().enumerate(); - for (i, line) in iter.by_ref() { - if line.line_i == start.line - && let Some(start_x) = index_x(&line, start.index) - { - if start.line == end.line - && let Some(end_x) = index_x(&line, end.index) - { - yield (i, start_x, end_x - start_x); - return; - } - yield (i, start_x, line.line_w - start_x); - break; - } - } - for (i, line) in iter { - if line.line_i > end.line { - return; - } - if line.line_i == end.line - && let Some(end_x) = index_x(&line, end.index) - { - yield (i, 0.0, end_x); - return; - } - yield (i, 0.0, line.line_w); - } - } -} - -/// copied & modified from fn found in Editor in cosmic_text -/// returns x pos of a (non layout) index within an layout run -fn index_x(run: &LayoutRun, index: usize) -> Option { - for glyph in run.glyphs.iter() { - if index == glyph.start { - return Some(glyph.x); - } else if index > glyph.start && index < glyph.end { - // Guess x offset based on characters - let mut before = 0; - let mut total = 0; - - let cluster = &run.text[glyph.start..glyph.end]; - for (i, _) in cluster.grapheme_indices(true) { - if glyph.start + i < index { - before += 1; - } - total += 1; - } - - let offset = glyph.w * (before as f32) / (total as f32); - return Some(glyph.x + offset); - } - } - None -} - -/// returns top of line segment where cursor should visually select -fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option { - let mut prev = None; - for run in buf - .layout_runs() - .skip_while(|r| r.line_i < cursor.line) - .take_while(|r| r.line_i == cursor.line) - { - prev = Some(vec2(run.line_w, run.line_top)); - if let Some(pos) = index_x(&run, cursor.index) { - return Some(vec2(pos, run.line_top)); - } - } - prev -} +const CARET_WIDTH: f32 = 1.0; pub struct TextEditCtx<'a> { pub text: &'a mut TextEdit, - pub font_system: &'a mut FontSystem, + pub data: &'a mut TextData, } impl<'a> TextEditCtx<'a> { + /// The layout, brought up to date with the text first. + /// + /// Every cursor movement and hit test goes through parley's layout, so an + /// edit that left it stale would move the caret against the previous text. + /// Shaping is skipped when nothing changed, so calling this freely is fine. + fn layout(&mut self) -> &Layout { + let attrs = self.text.view.attrs.clone(); + let width = self.text.view.wrap_width(); + self.text.view.buf.shape(self.data, &attrs, width); + self.text.view.buf.layout() + } + + /// Keep the selection valid after the text underneath it changed. + fn refresh(&mut self) { + if let Some(sel) = self.text.selection { + let layout = self.layout(); + self.text.selection = Some(sel.refresh(layout)); + } + } + pub fn take(&mut self) -> String { - let text = self - .text - .buf - .lines - .drain(..) - .map(|l| l.into_text()) - .collect::>() - .join("\n"); - self.text - .buf - .set_text(self.font_system, "", &Attrs::new(), SHAPING, None); - self.text.selection.clear(); + let text = self.text.view.buf.text().to_string(); + self.set(""); text } pub fn set(&mut self, text: &str) { let text = self.string(text); - self.text - .buf - .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None); - self.text.selection.clear(); + self.text.view.buf.set_text(text); + self.text.view.buf.changed = true; + self.text.selection = None; } pub fn motion(&mut self, motion: Motion, select: bool) { - if let TextSelection::Pos(cursor) = self.text.selection - && let Some(new) = self.buf_motion(cursor, motion) - { - if select { - self.text.selection = TextSelection::Span { - start: cursor, - end: new, - }; - } else { - self.text.selection = TextSelection::Pos(new); - } - } else if let TextSelection::Span { start, end } = self.text.selection { - if select { - if let Some(cursor) = self.buf_motion(end, motion) { - self.text.selection = TextSelection::Span { start, end: cursor }; + let Some(sel) = self.text.selection else { + return; + }; + let layout = self.layout(); + // Collapsing a span with an unshifted left/right puts the caret at the + // near end rather than moving one character from the focus, which is + // what every other editor does. + let sel = if !select && !sel.is_collapsed() { + match motion { + Motion::Left | Motion::LeftWord => { + Selection::from(sel.text_range().start_cursor(layout)) } - } else { - let (start, end) = sort_cursors(start, end); - let sel = &mut self.text.selection; - match motion { - Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start), - Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end), - _ => { - if let Some(cursor) = self.buf_motion(end, motion) { - self.text.selection = TextSelection::Pos(cursor); - } - } + Motion::Right | Motion::RightWord => { + Selection::from(sel.text_range().end_cursor(layout)) } + _ => apply_motion(sel, layout, motion, false), } - } + } else { + apply_motion(sel, layout, motion, select) + }; + self.text.selection = Some(sel); } + /// Replace the `len` characters before the caret. This is the IME's + /// preedit path: it re-sends the whole composition each time. pub fn replace(&mut self, len: usize, text: &str) { let text = self.string(text); for _ in 0..len { - self.delete(false); + self.backspace(false); } - self.insert_inner(&text, false); + self.insert_str(&text); } fn string(&self, text: &str) -> String { @@ -261,202 +186,174 @@ impl<'a> TextEditCtx<'a> { pub fn insert(&mut self, text: &str) { let text = self.string(text); - let mut lines = text.split('\n'); - let Some(first) = lines.next() else { + self.insert_str(&text); + } + + fn insert_str(&mut self, text: &str) { + if text.is_empty() { return; - }; - self.insert_inner(first, true); - for line in lines { - self.newline(); - self.insert_inner(line, true); } - } - - pub fn clear_span(&mut self) -> bool { - if let TextSelection::Span { start, end } = self.text.selection { - self.delete_between(start, end); - let (start, _) = sort_cursors(start, end); - self.text.selection = TextSelection::Pos(start); - true - } else { - false - } - } - - pub fn delete_between(&mut self, start: Cursor, end: Cursor) { - let lines = &mut self.text.view.buf.lines; - let (start, end) = sort_cursors(start, end); - if start.line == end.line { - let line = &mut lines[start.line]; - let text = line.text(); - let text = text[..start.index].to_string() + &text[end.index..]; - edit_line(line, text); - } else { - // start - let start_text = lines[start.line].text()[..start.index].to_string(); - let end_text = &lines[end.line].text()[end.index..]; - let text = start_text + end_text; - edit_line(&mut lines[start.line], text); - } - // between - let range = (start.line + 1)..=end.line; - if !range.is_empty() { - lines.splice(range, None); - } - } - - fn insert_inner(&mut self, text: &str, mov: bool) { self.clear_span(); - if let TextSelection::Pos(cursor) = &mut self.text.selection { - let line = &mut self.text.view.buf.lines[cursor.line]; - let mut line_text = line.text().to_string(); - line_text.insert_str(cursor.index, text); - edit_line(line, line_text); - if mov { - for _ in 0..text.chars().count() { - self.motion(Motion::Right, false); - } - } + let at = match self.text.selection { + Some(sel) => sel.focus().index(), + None => return, + }; + let at = at.min(self.text.view.buf.text().len()); + self.text.view.buf.edit().insert_str(at, text); + self.text.view.buf.changed = true; + self.set_caret(at + text.len()); + } + + /// True when there was a span to remove. + pub fn clear_span(&mut self) -> bool { + let Some(sel) = self.text.selection else { + return false; + }; + if sel.is_collapsed() { + return false; } + let range = sel.text_range(); + self.text.view.buf.edit().replace_range(range.clone(), ""); + self.text.view.buf.changed = true; + self.set_caret(range.start); + true + } + + fn set_caret(&mut self, index: usize) { + let index = index.min(self.text.view.buf.text().len()); + let layout = self.layout(); + self.text.selection = Some(Selection::from_byte_index( + layout, + index, + Affinity::default(), + )); } pub fn newline(&mut self) { - if self.text.mode == EditMode::SingleLine { - return; - } - self.clear_span(); - if let TextSelection::Pos(cursor) = &mut self.text.selection { - let lines = &mut self.text.view.buf.lines; - let line = &mut lines[cursor.line]; - let new = line.split_off(cursor.index); - cursor.line += 1; - lines.insert(cursor.line, new); - cursor.index = 0; + if self.text.mode == EditMode::MultiLine { + self.insert_str("\n"); } } pub fn backspace(&mut self, word: bool) { - if !self.clear_span() - && let TextSelection::Pos(cursor) = &mut self.text.selection - && (cursor.index != 0 || cursor.line != 0) - { - self.motion(if word { Motion::LeftWord } else { Motion::Left }, false); - self.delete(word); + if self.clear_span() { + return; } + let Some(sel) = self.text.selection else { + return; + }; + let end = sel.focus().index(); + if end == 0 { + return; + } + let layout = self.layout(); + let start = if word { + sel.focus().previous_logical_word(layout).index() + } else { + sel.focus().previous_visual(layout).index() + }; + self.delete_range(start, end); } pub fn delete(&mut self, word: bool) { - if !self.clear_span() - && let TextSelection::Pos(cursor) = &mut self.text.selection - { - if word { - let start = *cursor; - if let Some(end) = self.buf_motion(start, Motion::RightWord) { - self.delete_between(start, end); - } - } else { - let lines = &mut self.text.view.buf.lines; - let line = &mut lines[cursor.line]; - if cursor.index == line.text().len() { - if cursor.line == lines.len() - 1 { - return; - } - let add = lines.remove(cursor.line + 1).into_text(); - let line = &mut lines[cursor.line]; - let mut cur = line.text().to_string(); - cur.push_str(&add); - edit_line(line, cur); - } else { - let mut text = line.text().to_string(); - text.remove(cursor.index); - edit_line(line, text); - } - } + if self.clear_span() { + return; } + let Some(sel) = self.text.selection else { + return; + }; + let start = sel.focus().index(); + if start >= self.text.view.buf.text().len() { + return; + } + let layout = self.layout(); + let end = if word { + sel.focus().next_logical_word(layout).index() + } else { + sel.focus().next_visual(layout).index() + }; + self.delete_range(start, end); } - fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option { - self.text - .buf - .cursor_motion(self.font_system, cursor, None, motion) - .map(|r| r.0) + fn delete_range(&mut self, start: usize, end: usize) { + let len = self.text.view.buf.text().len(); + let (start, end) = (start.min(end).min(len), start.max(end).min(len)); + if start == end { + return; + } + self.text.view.buf.edit().replace_range(start..end, ""); + self.text.view.buf.changed = true; + self.set_caret(start); } - pub fn select_word_at(&mut self, cursor: Cursor) { - if let (Some(start), Some(end)) = ( - self.buf_motion(cursor, Motion::LeftWord), - self.buf_motion(cursor, Motion::RightWord), - ) { - self.text.selection = TextSelection::Span { start, end }; - } - } - - pub fn select_line_at(&mut self, cursor: Cursor) { - let end = self.text.buf.lines[cursor.line].text().len(); - self.text.selection = TextSelection::Span { - start: Cursor::new(cursor.line, 0), - end: Cursor::new(cursor.line, end), + pub fn select_all(&mut self) { + let len = self.text.view.buf.text().len(); + if len == 0 { + return; } + let layout = self.layout(); + let anchor = parley::Cursor::from_byte_index(layout, 0, Affinity::default()); + let focus = parley::Cursor::from_byte_index(layout, len, Affinity::default()); + self.text.selection = Some(Selection::new(anchor, focus)); } pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) { let pos = pos - self.text.region().top_left().to_abs(size); - let hit = self.text.buf.hit(pos.x, pos.y); - let sel = &mut self.text.selection; - match sel { - TextSelection::None => { - if !drag && let Some(hit) = hit { - *sel = TextSelection::Pos(hit) - } + let prev_sel = self.text.selection; + let prev_hit = self.text.double_hit; + + // The layout borrows `self`, so the whole decision is made in here and + // only the answer escapes. + let outcome = { + let layout = self.layout(); + let inside = + pos.x >= 0.0 && pos.y >= 0.0 && pos.x <= layout.width() && pos.y <= layout.height(); + + if !inside { + if drag { None } else { Some((None, None)) } + } else if drag { + prev_sel.map(|sel| (Some(sel.extend_to_point(layout, pos.x, pos.y)), prev_hit)) + } else { + let hit = Selection::from_point(layout, pos.x, pos.y); + let index = hit.focus().index(); + // A second click in the same place takes the word and a third + // the line; `double_hit` is what remembers that the previous + // click had already grown to a word. + Some(if recent && prev_hit == Some(index) { + (Some(Selection::line_from_point(layout, pos.x, pos.y)), None) + } else if recent && prev_sel.map(|s| s.focus().index()) == Some(index) { + ( + Some(Selection::word_from_point(layout, pos.x, pos.y)), + Some(index), + ) + } else { + (Some(hit), None) + }) } - TextSelection::Pos(pos) => match (hit, drag) { - (None, false) => *sel = TextSelection::None, - (None, true) => (), - (Some(hit), false) => { - if recent && hit == *pos { - self.text.double_hit = Some(hit); - return self.select_word_at(hit); - } else { - *pos = hit - } - } - (Some(end), true) => *sel = TextSelection::Span { start: *pos, end }, - }, - TextSelection::Span { start, end } => match (hit, drag) { - (None, false) => *sel = TextSelection::None, - (None, true) => *sel = TextSelection::Pos(*start), - (Some(hit), false) => { - if recent - && let Some(double) = self.text.double_hit - && double == hit - { - return self.select_line_at(hit); - } else { - *sel = TextSelection::Pos(hit) - } - } - (Some(hit), true) => *end = hit, - }, - } - if let TextSelection::Span { start, end } = sel - && start == end - { - *sel = TextSelection::Pos(*start); + }; + + if let Some((selection, double_hit)) = outcome { + self.text.selection = selection; + self.text.double_hit = double_hit; } } pub fn deselect(&mut self) { - self.text.selection = TextSelection::None; + self.text.selection = None; + self.text.double_hit = None; } pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult { - let old = (self.text.content(), self.text.selection); + let old = (self.text.view.buf.text().to_string(), self.text.selection); let mut undo = false; let res = self.apply_event_inner(event, modifiers, &mut undo); - if undo && let Some((old, selection)) = self.text.history.pop() { - self.set(&old); - self.text.selection = selection; - } else if self.text.content() != old.0 { + if undo { + if let Some((old, selection)) = self.text.history.pop() { + self.set(&old); + self.text.selection = selection; + self.refresh(); + } + } else if self.text.view.buf.text() != old.0 { self.text.history.push(old); } res @@ -481,21 +378,25 @@ impl<'a> TextEditCtx<'a> { } } NamedKey::ArrowRight => { - if modifiers.control { - self.motion(Motion::RightWord, modifiers.shift) + let motion = if modifiers.control { + Motion::RightWord } else { - self.motion(Motion::Right, modifiers.shift) - } + Motion::Right + }; + self.motion(motion, modifiers.shift); } NamedKey::ArrowLeft => { - if modifiers.control { - self.motion(Motion::LeftWord, modifiers.shift) + let motion = if modifiers.control { + Motion::LeftWord } else { - self.motion(Motion::Left, modifiers.shift) - } + Motion::Left + }; + self.motion(motion, modifiers.shift); } NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift), NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift), + NamedKey::Home => self.motion(Motion::LineStart, modifiers.shift), + NamedKey::End => self.motion(Motion::LineEnd, modifiers.shift), NamedKey::Escape => { self.deselect(); return TextInputResult::Unfocus; @@ -507,34 +408,18 @@ impl<'a> TextEditCtx<'a> { match text.as_str() { "v" => return TextInputResult::Paste, "c" => { - if let TextSelection::Span { start, end } = self.text.selection { - let content = self.text.select_content(start, end); + if let Some(content) = self.text.selected_text() { return TextInputResult::Copy(content); } } "x" => { - if let TextSelection::Span { start, end } = self.text.selection { - let content = self.text.select_content(start, end); + if let Some(content) = self.text.selected_text() { self.clear_span(); return TextInputResult::Copy(content); } } - "a" => { - if !self.text.buf.lines[0].text().is_empty() - || self.text.buf.lines.len() > 1 - { - let lines = &self.text.buf.lines; - let last_line = lines.len() - 1; - let last_idx = lines[last_line].text().len(); - self.text.selection = TextSelection::Span { - start: Cursor::new(0, 0), - end: Cursor::new(last_line, last_idx), - }; - } - } - "z" => { - *undo = true; - } + "a" => self.select_all(), + "z" => *undo = true, _ => self.insert(text), } } else { @@ -547,6 +432,40 @@ impl<'a> TextEditCtx<'a> { } } +fn apply_motion( + sel: Selection, + layout: &Layout, + motion: Motion, + extend: bool, +) -> Selection { + match motion { + Motion::Left => sel.previous_visual(layout, extend), + Motion::Right => sel.next_visual(layout, extend), + Motion::LeftWord => sel.previous_visual_word(layout, extend), + Motion::RightWord => sel.next_visual_word(layout, extend), + Motion::Up => sel.previous_line(layout, extend), + Motion::Down => sel.next_line(layout, extend), + Motion::LineStart => sel.line_start(layout, extend), + Motion::LineEnd => sel.line_end(layout, extend), + } +} + +/// The ends of a byte range as cursors, so collapsing a selection can put the +/// caret at whichever end the movement asked for. +trait RangeCursors { + fn start_cursor(&self, layout: &Layout) -> parley::Cursor; + fn end_cursor(&self, layout: &Layout) -> parley::Cursor; +} + +impl RangeCursors for std::ops::Range { + fn start_cursor(&self, layout: &Layout) -> parley::Cursor { + parley::Cursor::from_byte_index(layout, self.start, Affinity::default()) + } + fn end_cursor(&self, layout: &Layout) -> parley::Cursor { + parley::Cursor::from_byte_index(layout, self.end, Affinity::default()) + } +} + #[derive(Default)] pub struct Modifiers { pub shift: bool, @@ -569,33 +488,6 @@ pub enum TextInputResult { Paste, } -#[derive(Debug, Default, Clone, Copy)] -pub enum TextSelection { - #[default] - None, - Pos(Cursor), - Span { - start: Cursor, - end: Cursor, - }, -} - -impl TextSelection { - pub fn clear(&mut self) { - match self { - TextSelection::None => (), - TextSelection::Pos(cursor) => { - cursor.line = 0; - cursor.index = 0; - cursor.affinity = Affinity::default(); - } - TextSelection::Span { start: _, end: _ } => { - *self = TextSelection::None; - } - } - } -} - impl TextInputResult { pub fn unfocus(&self) -> bool { matches!(self, TextInputResult::Unfocus) @@ -625,7 +517,7 @@ impl> TextEditable for I { let ui = ui.ui_mut(); TextEditCtx { text: ui.widgets.get_mut(self).unwrap(), - font_system: &mut ui.text.font_system, + data: &mut ui.text, } } } diff --git a/iris/src/widget/text/mod.rs b/iris/src/widget/text/mod.rs index cc9c94f..0c69086 100644 --- a/iris/src/widget/text/mod.rs +++ b/iris/src/widget/text/mod.rs @@ -6,11 +6,8 @@ pub use edit::*; use iris_core::util::MutDetect; use crate::prelude::*; -use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping}; use std::ops::{Deref, DerefMut}; -pub const SHAPING: Shaping = Shaping::Advanced; - pub struct Text { pub content: MutDetect, view: TextView, @@ -25,6 +22,18 @@ pub struct TextView { pub hint: Option, } +impl TextView { + fn is_blank(&self) -> bool { + self.buf.is_empty() + } + + /// The width the text was last laid out against, so an editor asking for + /// the layout gets the same wrapping the last draw used. + pub fn wrap_width(&self) -> Option { + self.width + } +} + impl TextView { pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option) -> Self { Self { @@ -45,15 +54,6 @@ impl TextView { .align(self.align) } - fn tex_region(&self, tex: &RenderedText) -> UiRegion { - let region = tex.size.align(self.align); - let dims = tex.handle.size(); - let mut region = region.offset(tex.top_left_offset); - region.x.end = region.x.start + UiScalar::abs(dims.x); - region.y.end = region.y.start + UiScalar::abs(dims.y); - region - } - fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText { let width = if self.attrs.wrap { Some(ctx.px_size().x) @@ -68,10 +68,7 @@ impl TextView { return tex.clone(); } self.width = width; - let font_system = &mut ctx.text.font_system; - self.attrs.apply(font_system, &mut self.buf, width); - self.buf.shape_until_scroll(font_system, false); - let tex = ctx.draw_text(&mut self.buf, &self.attrs); + let tex = ctx.draw_text(&mut self.buf, &self.attrs, width); self.tex = Some(tex.clone()); self.attrs.changed = false; self.buf.changed = false; @@ -81,9 +78,8 @@ impl TextView { self.tex.as_ref() } pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { - if let Some(hint) = &self.hint - && let [line] = &self.buf.lines[..] - && line.text().is_empty() + if self.is_blank() + && let Some(hint) = &self.hint { ctx.width(hint) } else { @@ -91,9 +87,8 @@ impl TextView { } } pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { - if let Some(hint) = &self.hint - && let [line] = &self.buf.lines[..] - && line.text().is_empty() + if self.is_blank() + && let Some(hint) = &self.hint { ctx.height(hint) } else { @@ -102,47 +97,35 @@ impl TextView { } pub fn draw(&mut self, painter: &mut Painter) -> UiRegion { let tex = self.render(&mut painter.size_ctx()); - let region = self.tex_region(&tex); - if let Some(hint) = &self.hint - && let [line] = &self.buf.lines[..] - && line.text().is_empty() + let region = tex.size.align(self.align); + if self.is_blank() + && let Some(hint) = &self.hint { painter.widget(hint); } else { - painter.texture_within(&tex.handle, region); + let within = region.within(&painter.region()); + painter.glyphs(&tex, within); } region } pub fn content(&self) -> String { - self.buf - .lines - .iter() - .map(|l| l.text()) - .collect::>() - .join("\n") + self.buf.text().to_string() } } impl Text { pub fn new(content: impl Into) -> Self { - let attrs = TextAttrs::default(); - let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height)); + let content: String = content.into(); Self { - content: content.into().into(), - view: TextView::new(buf, attrs, None), + view: TextView::new(TextBuffer::new(&content), TextAttrs::default(), None), + content: content.into(), } } - fn update_buf(&mut self, ctx: &mut SizeCtx) { + fn update_buf(&mut self, _ctx: &mut SizeCtx) { if self.content.changed { self.content.changed = false; - self.view.buf.set_text( - &mut ctx.text.font_system, - &self.content, - &Attrs::new().family(self.view.attrs.family), - SHAPING, - None, - ); + self.view.buf.set_text(self.content.as_str()); } } } @@ -164,16 +147,6 @@ impl Widget for Text { } } -pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) { - let start = a.min(b); - let end = a.max(b); - (start, end) -} - -pub fn edit_line(line: &mut BufferLine, text: String) { - line.set_text(text, line.ending(), line.attrs_list().clone()); -} - impl Deref for Text { type Target = TextAttrs; From ff7e9c0435ffbc109586bab0b2851e287842f088 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:27:57 -0400 Subject: [PATCH 13/77] Test iris's editor, which had no coverage and was just rewritten iris has no tests at all, and the rule here is not to erect a harness where there is none -- but the editor is the exception on both counts. It is the one part of the library that is pure logic over a string and a layout rather than something needing a GPU and a window, and it was just rewritten wholesale onto parley's selection model with no way to exercise it: input cannot be synthesised in the headless compositor the examples run under, because it has no seat devices. Fourteen tests over insert, backspace, delete, span clearing, select-all, motion, single- versus multi-line, and take. Two are there for specific things the rewrite could plausibly have broken: the IME preedit path, which resends its whole composition each keystroke so `replace` has to remove exactly what it added last time, and editing text with multi-byte characters, since parley addresses by byte offset where the old code counted (line, index). Co-Authored-By: Claude Opus 5 --- iris/src/widget/text/edit.rs | 155 +++++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) diff --git a/iris/src/widget/text/edit.rs b/iris/src/widget/text/edit.rs index 90f6eea..4f209fe 100644 --- a/iris/src/widget/text/edit.rs +++ b/iris/src/widget/text/edit.rs @@ -521,3 +521,158 @@ impl> TextEditable for I { } } } + +#[cfg(test)] +mod tests { + use super::*; + use iris_core::{TextAttrs, TextBuffer}; + + /// The editor is the one part of iris that is pure logic over a string and + /// a layout, and it was rewritten wholesale when the text stack changed -- + /// so it is the one part worth testing directly. Everything else here + /// needs a GPU and a window. + fn edit(text: &str, mode: EditMode) -> (TextEdit, TextData) { + let view = TextView::new(TextBuffer::new(text), TextAttrs::default(), None); + (TextEdit::new(view, mode), TextData::default()) + } + + fn ctx<'a>(text: &'a mut TextEdit, data: &'a mut TextData) -> TextEditCtx<'a> { + TextEditCtx { text, data } + } + + fn content(text: &TextEdit) -> String { + text.buf.text().to_string() + } + + #[test] + fn insert_at_the_caret() { + let (mut t, mut d) = edit("ac", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(1); + ctx(&mut t, &mut d).insert("b"); + assert_eq!(content(&t), "abc"); + assert_eq!(t.selection.unwrap().focus().index(), 2); + } + + #[test] + fn backspace_removes_the_character_before_the_caret() { + let (mut t, mut d) = edit("abc", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(2); + ctx(&mut t, &mut d).backspace(false); + assert_eq!(content(&t), "ac"); + } + + #[test] + fn backspace_at_the_start_does_nothing() { + let (mut t, mut d) = edit("abc", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(0); + ctx(&mut t, &mut d).backspace(false); + assert_eq!(content(&t), "abc"); + } + + #[test] + fn delete_removes_the_character_after_the_caret() { + let (mut t, mut d) = edit("abc", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(1); + ctx(&mut t, &mut d).delete(false); + assert_eq!(content(&t), "ac"); + } + + #[test] + fn delete_at_the_end_does_nothing() { + let (mut t, mut d) = edit("abc", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(3); + ctx(&mut t, &mut d).delete(false); + assert_eq!(content(&t), "abc"); + } + + #[test] + fn select_all_then_typing_replaces_everything() { + let (mut t, mut d) = edit("hello", EditMode::SingleLine); + ctx(&mut t, &mut d).select_all(); + assert_eq!(t.selected_text().as_deref(), Some("hello")); + ctx(&mut t, &mut d).insert("x"); + assert_eq!(content(&t), "x"); + } + + #[test] + fn clearing_a_span_leaves_the_caret_at_its_start() { + let (mut t, mut d) = edit("abcdef", EditMode::SingleLine); + ctx(&mut t, &mut d).select_all(); + assert!(ctx(&mut t, &mut d).clear_span()); + assert_eq!(content(&t), ""); + assert_eq!(t.selection.unwrap().focus().index(), 0); + } + + #[test] + fn a_single_line_field_refuses_newlines() { + let (mut t, mut d) = edit("", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(0); + ctx(&mut t, &mut d).insert("a\nb"); + assert_eq!(content(&t), "ab"); + ctx(&mut t, &mut d).newline(); + assert_eq!(content(&t), "ab"); + } + + #[test] + fn a_multi_line_field_keeps_newlines() { + let (mut t, mut d) = edit("", EditMode::MultiLine); + ctx(&mut t, &mut d).set_caret(0); + ctx(&mut t, &mut d).insert("a\nb"); + assert_eq!(content(&t), "a\nb"); + } + + #[test] + fn take_empties_the_field_and_hands_back_what_was_there() { + let (mut t, mut d) = edit("some text", EditMode::SingleLine); + assert_eq!(ctx(&mut t, &mut d).take(), "some text"); + assert_eq!(content(&t), ""); + } + + /// The IME's preedit path: each keystroke resends the whole composition, + /// so `replace` has to remove exactly what it added last time. + #[test] + fn ime_preedit_replaces_its_own_previous_text() { + let (mut t, mut d) = edit("", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(0); + ctx(&mut t, &mut d).replace(0, "n"); + assert_eq!(content(&t), "n"); + ctx(&mut t, &mut d).replace(1, "ni"); + assert_eq!(content(&t), "ni"); + ctx(&mut t, &mut d).replace(2, "に"); + assert_eq!(content(&t), "に"); + } + + #[test] + fn motion_moves_the_caret_and_shift_extends_a_span() { + let (mut t, mut d) = edit("abc", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(0); + ctx(&mut t, &mut d).motion(Motion::Right, false); + assert_eq!(t.selection.unwrap().focus().index(), 1); + ctx(&mut t, &mut d).motion(Motion::Right, true); + assert_eq!(t.selected_text().as_deref(), Some("b")); + } + + /// Collapsing a span with an unshifted arrow goes to the near end rather + /// than stepping one character from the focus. + #[test] + fn an_unshifted_arrow_collapses_a_span_to_its_edge() { + let (mut t, mut d) = edit("abcdef", EditMode::SingleLine); + ctx(&mut t, &mut d).select_all(); + ctx(&mut t, &mut d).motion(Motion::Left, false); + assert_eq!(t.selection.unwrap().focus().index(), 0); + + ctx(&mut t, &mut d).select_all(); + ctx(&mut t, &mut d).motion(Motion::Right, false); + assert_eq!(t.selection.unwrap().focus().index(), 6); + } + + /// Byte offsets, not character counts: a caret placed after a multi-byte + /// character must not split it. + #[test] + fn multibyte_text_is_edited_by_byte_offset() { + let (mut t, mut d) = edit("aé", EditMode::SingleLine); + ctx(&mut t, &mut d).set_caret(3); + ctx(&mut t, &mut d).backspace(false); + assert_eq!(content(&t), "a"); + } +} From 1a97d0ef5c22cdb5edea18a6580645dff3f11102 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:28:22 -0400 Subject: [PATCH 14/77] RUST.md: record I1 -- parley and the atlas, and what is still unmeasured Iris decided for parley directly rather than through the comparison this step described, and asked for the glyph atlas with it, so the step is what was built rather than what was chosen between. Records the view count dropping from 6 to 1 as the evidence the atlas is doing its job, and says plainly that the speed claim behind the TODO is still unmeasured in both directions -- it wants I5's transcript screen to be worth timing. Co-Authored-By: Claude Opus 5 --- RUST.md | 67 +++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 56 insertions(+), 11 deletions(-) diff --git a/RUST.md b/RUST.md index 8193a80..eb47386 100644 --- a/RUST.md +++ b/RUST.md @@ -648,17 +648,62 @@ step measured. latent on Wayland only because winit asks for a redraw after a resize by itself; on Android, where the surface work of I2 will not have winit underneath it, nothing else here would have asked. -- [ ] **I1 — the text stack decision.** iris uses cosmic-text; the - transcript needs rich inline spans (links, code chips, colour), - selection across many widgets with the platform's handles on the - phone, and an editor the IME can drive (composition regions, not - just committed characters). Compare cosmic-text and Parley against - exactly those three, in iris, on a real transcript's text. Parley - is the expectation because android-view's IME bridge and AccessKit's - text properties are written against it; measure rather than assume. - Pass: a written decision here with what each was tried on, and the - TODO's "text resizing per frame is really slow" measured and either - fixed or explained. +- [x] **I1 — parley, and a glyph atlas (done 2026-09-04).** No bake-off: + Iris decided for parley directly ("I wanted to switch it to parley + anyways"), and then asked for the atlas as well ("just do the atlas, + commit to it, we do want it"). Both are in. + + **What parley bought, beyond shaping.** Its editing model addresses + text by byte offset into one string, where cosmic-text used + `(line, index)` — so `select_content`, `delete_between`, + `insert_inner` and `newline` collapse into ordinary string + operations. Bigger: `Selection::geometry` and `Cursor::geometry` + replace `iter_layout_lines`, `index_x` and `cursor_pos`, which walked + runs by hand to place the caret and the selection boxes and were not + bidi- or wrap-correct. `edit.rs` lost about 130 lines and gained + Home/End. Its cursor motions map onto parley's `next_visual`, + `previous_visual_word`, `next_line` and so on, in one function. + + **The atlas is what "text resizing (per frame) is really slow" + was.** Every string used to be rasterised into its own `RgbaImage` + and uploaded as a whole texture whenever anything about it changed, + so a window resize re-rasterised and re-uploaded every visible + string. Now a glyph is rasterised once per font, size and subpixel + phase, shared by every string that contains it, and a resize + re-emits quads without touching the GPU's copy. **The tabs example + reports it: `views`, the number of texture views bound, went from 6 + to 1** — six per-string textures became one shared page. Supporting + pieces: a `GLYPH` primitive that samples a sub-rectangle and tints + it (the existing texture primitive samples a whole texture), a + `Patch` texture update so a new glyph costs its own bytes rather + than a 4 MB page, and `GpuTextures` keeping its `Texture`s, since a + view cannot be written through. + + **Not yet measured**, and the honest gap in this step: the TODO's + "really slow" was never given a number, so neither is the + improvement. What is evidence rather than argument is the view count + and the shape of the work — a resize no longer rasterises. A + before/after timing wants the transcript screen of I5 to be worth + taking. + + **Two bugs found on the way**, both pre-existing: `primitives!`'s + `@count` rule recursed comma-separated while matching + space-separated, so it terminated only for exactly two primitives + and adding a third hit the recursion limit; and `Color` had no + `Default`, which parley's `Brush` requires. + + **Fourteen tests**, iris's first. The editor is the one part that is + pure logic rather than something needing a GPU and a window, and it + was rewritten wholesale with no way to exercise it — synthetic input + does not reach a client under the headless compositor, which has no + seat devices. Two of the tests are aimed at what the rewrite could + plausibly have broken: the IME preedit path, and editing multi-byte + text now that offsets are bytes. + + Dropping cosmic-text and unicode-segmentation also retired two + nightly gates — `portable_simd` (the old glyph compositing) and + `gen_blocks` (the deleted line iterator). **Eleven left.** + - [ ] **I2 — iris on android-view.** An `android-view` surface as a second backend beside winit: `wgpu` on the view's surface (GLES here, see the Vulkan section; Vulkan on the phone), touch as pointer events, From 43743ba171e37391d5901a9418ca257a607efbfb Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:32:41 -0400 Subject: [PATCH 15/77] RUST.md: bring it up to date, and say it must be kept that way Adds a "Keep this file current as you work" section at the top saying what it is for: this file is the handoff, so writing results into it as they arrive is what lets a session that has filled its context be cleared instead of carrying the conversation or re-deriving what was measured. It asks for the dead ends too, since those are what stop the next session spending an afternoon somewhere already ruled out. Adds a "Where things stand" block, because the next agent's first question is which box is next and the answer was previously spread across the list: E0, E1, I0a, I0b and I1 done, I2 next with E2 able to run in parallel, client-core not started, and the two emulator-tools changes made outside this repo. Corrects what had gone stale: the next-agent steps still said to start at E0; the iris section still described a fourteen-gate cosmic-text tree and called the text stack an open question; and the weight section still spoke of E1 as something that would happen. It now carries the numbers instead -- 43s and 2.1 GB against 1m46s and 1.5 GB for iris, and 181 MB debug against 11 MB release for the Masonry demo. Adds the rule about bounding heavy runs with a kill timer scoped to the pid, which cost a wrong conclusion here. Co-Authored-By: Claude Opus 5 --- RUST.md | 118 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 93 insertions(+), 25 deletions(-) diff --git a/RUST.md b/RUST.md index eb47386..cbdf3eb 100644 --- a/RUST.md +++ b/RUST.md @@ -14,8 +14,50 @@ this clone is where things get tried before anything is committed to **in-house framework to be built up** for this, with Masonry as the yardstick it is measured against. -Decisions get a date and a reason here, the way `PLAN.md` does. Nothing in -this file has been tried yet unless a section says it has. +Decisions get a date and a reason here, the way `PLAN.md` does. A section +describes something that has been tried only where it says so, with a date. + +## Keep this file current as you work + +**This file is the handoff, and it is meant to let a session be cleared.** +Write each result into it *as you get it*, not at the end: the box ticked +or the reason it could not be, the measurement with its number, the +decision with its date and what it rejected, and anything that cost time to +find out. Then a session that has filled its context can be cleared and the +next one can pick up from this file alone, which is much cheaper than +carrying a long conversation or re-deriving what was already measured. + +Two things that follow. Write for somebody who was not here — name the +command, the file and the number rather than "the fix" or "the earlier +run". And write the failures and the dead ends too: "Venus is blocked by +the emulator, not by Mesa" and "the present mode was not the cause" are +worth as much as the successes, because they are what stops the next +session spending an afternoon on them again. + +## Where things stand (2026-09-04) + +- **Done**: E0 (toolchain), E1 (Masonry on android-view, which found the + keyboard gap), I0a, I0b (iris builds on a pinned nightly and runs), I1 + (parley + glyph atlas). +- **Next**: **I2** — iris on android-view. E1 says the first thing to + answer there is why the editor gets keystrokes but no autocorrect or + suggestions, since that is the constraint the framework decision turns + on. **E2** (a transcript in Masonry) can go in parallel in another + session. +- **Not started**: `client-core`, which is item 1 of the recommendation + below and does not depend on the framework choice. Nothing has been + built for it, and it is not one of the numbered boxes — worth picking up + in a session that wants work independent of the emulator. +- **The app itself is untouched.** Everything so far is in `iris/` and in + the rigs; nothing under `app/` or `server/` has changed. +- **Changed outside this repo**, both in `emulator-tools` and both pushed: + `avd_serial` now validates its cache by asking the device its AVD name + rather than by checking the serial is still attached (a recycled port + silently pointed this checkout at another session's emulator), and + `EMU_GPU=software` was added as an opt-in that keeps a run off the host + GPU and gives the guest a software Vulkan device. The default is + unchanged, because `-gpu host` was measured and the Compose benchmarks + depend on it. ## What has to be reproduced @@ -317,7 +359,8 @@ Desktop runs on winit. Vello needs a compute-capable GPU or falls back to [cat16/iris](https://github.com/cat16/iris), read 2026-09-04 from the one public commit (2026-01-31, "portfolio copy"; ~8,700 lines in `core`, `macro` and the crate itself). Retained-mode widgets stored outside the -render tree, `wgpu` 28 directly, `winit` 0.30, `cosmic-text` 0.16, a +render tree, `wgpu` 28 directly, `winit` 0.30, `cosmic-text` 0.16 (parley +since I1), a relative-anchor-plus-offset layout with `rest()` and `rel()` lengths, a postfix builder API (`rect(..).radius(30).on(CursorSense::click(), ..) .sized(..).align(..)`), events handled where the widget is declared, and @@ -325,10 +368,17 @@ a single-threaded context passed explicitly — all of which reads like this codebase's own rules. There is text editing (`widget/text/edit.rs`), images, masks, spans and stacks; the TODO names text resizing as per-frame slow and scaling as unsolved. It requires **nightly** (fourteen -`#![feature]` gates, among them `const_trait_impl`, `unboxed_closures`, -`portable_simd`, `associated_type_defaults`). Desktop only; no Android -surface, no IME, no accessibility tree, no virtualised list, no rich-text -selection. +`#![feature]` gates as vendored, among them `const_trait_impl`, +`unboxed_closures`, `portable_simd`, `associated_type_defaults`; eleven +after I0b and I1 — see those steps for the current list). Desktop only; no +Android surface, no IME, no accessibility tree, no virtualised list, no +rich-text selection. + +**That list is the work, and some of it is done.** As of 2026-09-04 it +builds on a pinned nightly, runs on this machine's GPU, has parley and a +glyph atlas, and `iris-core` cross-compiles to Android. What it still +lacks from the list above is the Android surface, the IME bridge, the +accessibility tree and the virtualised list — I2, I3 and I4. **iris is not a candidate to be tested as it stands. It is the in-house library** (Iris, 2026-09-04): "essentially a good start to a rewrite from @@ -340,16 +390,16 @@ it needs are the same ones Masonry gets from android-view, Parley and AccessKit, and there is no reason iris cannot sit on those same foundations rather than reinvent them — the surface, the keyboard bridge and the accessibility tree are platform plumbing, not a framework's -identity. Whether the text stack stays cosmic-text or moves to Parley is -the first real design decision in that work (see I1 below). +identity. The text stack was the first real design decision in that work, +and it is settled: **Parley, with a glyph atlas** (I1, 2026-09-04). Two things to carry into that work honestly. Nightly is the opposite of "holds up long term": a build that breaks on a toolchain update, on the -machine Dev Updater builds on, unattended. Pin a dated nightly in -`rust-toolchain.toml` immediately, and keep a list of which `#![feature]` -gates are load-bearing so they can be retired as they stabilise or are -designed around. And a one-person framework carries every gap itself, -which is what Iris said she is willing to do. +machine Dev Updater builds on, unattended. **Done in I0b** — +`iris/rust-toolchain.toml` pins `nightly-2026-09-03` — and the gate list +lives with I0b and I1, to be retired as they stabilise or are designed +around; it is down from fourteen to eleven. And a one-person framework +carries every gap itself, which is what Iris said she is willing to do. "From scratch" therefore means iris, not a fourth thing. Masonry stays in the plan as the **yardstick and the fallback**: building its demo and its @@ -377,10 +427,18 @@ uses is to optimise dependencies while leaving the app crate at `opt-level [profile.dev.package."*"] opt-level = 2 -E1 measures this rather than remembering it: cold and incremental build -time, APK size, resident memory at rest and while streaming, and the -frame cost of one 800-event page — for the Masonry demo as shipped, then -with the profile above. Vello proper needs compute shaders and carries a +**Measured 2026-09-04, and it is not the widget layer.** iris's own +graph (wgpu + winit + cosmic-text at the time) built cold in **43s** with +a 2.1 GB `target/`, and **1m46s** with a 1.5 GB `target/` under the +profile above — so the knob costs build time and saves disk here, and +plain debug was never the problem. Masonry's graph is the one with Vello, +Parley, Fontique and Skrifa in it, and E1 gives the number that matters +for it: **`libmain.so` is 181 MB in debug and 11 MB in release.** That +size is also a correctness issue rather than only a weight one — a debug +build labels its Vulkan objects, and the emulator's driver segfaults in +`SetDebugUtilsObjectNameEXT` when it does. Runtime cost of the profile +knob is still unmeasured; resident memory and the frame cost of an +800-event page want E2. Vello proper needs compute shaders and carries a large shader set; `vello_hybrid` is lighter and Masonry can now render through either (or Vello CPU) via its `imaging` abstraction, so "keep it light" has a knob inside the same stack. @@ -737,18 +795,28 @@ re-derived: 2. Work on the **`rustify`** branch of this clone (`ai-app-2`), not on `main` and not in `ai-app`. Nothing on this branch is production until Iris says so. Commit and push as you go. -3. Take the next unchecked box above, in order: E0 first, then E1, then - the iris track from I0. E-steps and I-steps can proceed in parallel in - separate sessions once E1 has proved android-view on this emulator. +3. Take the next unchecked box above, in order. E1 has proved android-view + on this emulator, so the E-steps and the I-steps can now proceed in + parallel in separate sessions; see "Where things stand" at the top for + which is next. 4. Every step ends with its measurement written into this file beside the box, and the box ticked or the reason it could not be written in its - place. A step that is blocked says by what, not "later". + place. A step that is blocked says by what, not "later". Write it as you + go rather than at the end — see "Keep this file current as you work". 5. Run the existing rigs rather than inventing new ones: `ui-sandbox.sh` for a server with fixtures, `transcript-bench.sh` for the scroll baseline, `ui-trace` for anything positional, `emu up` for the - emulator. The Vulkan section below says how to get a Vulkan path in the - emulator when a `wgpu` backend needs one. -6. Decisions belong here with a date and what was rejected, the way + emulator, and `iris/run-headless.sh EXAMPLE --shot PNG` for an iris + example on this displayless machine. The Vulkan section below says how + to get a Vulkan path in the emulator when a `wgpu` backend needs one. +6. **Bound anything heavy at the moment you start it.** An emulator or a + long build gets a deadline — `timeout`, or a watchdog scoped to the pid + you just started — rather than a plan to stop it later. Scope it to + that pid: a watchdog written as `sleep N; emu down` fired into a later + experiment here and made a working Vulkan build look like a crash. And + stop the emulator when the work needing it is done rather than between + tasks. +7. Decisions belong here with a date and what was rejected, the way `PLAN.md` does it. Do not put design into commit messages alone. ### Vulkan in the emulator (measured 2026-09-04) From c70a670356a31716d54c567d72947841bd57e0a1 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 19:44:05 -0400 Subject: [PATCH 16/77] RUST.md: the Masonry IME gap is a TODO, and the accesskit abort is reproducible Two things E1 left open, both settled on the emulator. The missing autocorrect is Masonry's as_input_connection returning None, not android-view and not EditorInfo: android-view's own demo implements the trait over a parley editor and Gboard suggests from that buffer. The abort seen once is a client *detaching*: accesskit_android's adapter never returns to Inactive, so the first tree change after a ui-trace run sends an accessibility event with accessibility off, which throws. Co-Authored-By: Claude Opus 5 --- RUST.md | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 92 insertions(+), 3 deletions(-) diff --git a/RUST.md b/RUST.md index cbdf3eb..33d4a20 100644 --- a/RUST.md +++ b/RUST.md @@ -542,14 +542,103 @@ accepted. composition, autocorrect and suggestions are exactly what the composer in this app needs and exactly what `winit` cannot do at all. - *One crash seen once and not reproduced.* With an accessibility - client attached the app aborted, stack: + **Cause found 2026-09-04, and it is Masonry's, not android-view's.** + `~/src/android-view/masonry/src/lib.rs:531` is + + fn as_input_connection(&mut self) -> Option<&mut dyn InputConnection> { + // TODO + None + } + + so the Masonry demo has **no `InputConnection` at all**; `RustView` + returns null from `onCreateInputConnection` and the IME falls back to + dispatching raw key events, which is exactly the behaviour observed — + keys arrive, composition does not exist, so there is nothing for + Gboard to suggest against. It is not a wrong `EditorInfo`, and the + guess above that it was is withdrawn. + + android-view's **own** demo (`demo/src/lib.rs`, packaged by `app/`) + implements the whole trait against a parley editor and asks for + `INPUT_TYPE_CLASS_TEXT | CAP_SENTENCES | AUTO_CORRECT | MULTI_LINE` + with `IME_FLAG_NO_FULLSCREEN | NO_EXTRACT_UI | NO_ENTER_ACTION` + (`demo/src/lib.rs:588`). So the capability is present in the layer + iris would sit on, and the 30-odd method `InputConnection` trait in + `src/ime.rs` — `set_composing_text`, `set_composing_region`, + `finish_composing_text`, `text_before_cursor`, `cursor_caps_mode`, + `request_cursor_updates`, and `InputMethodManager::update_selection` + to push the selection back — is the full surface an IME needs. + **This changes what I2 costs**: the IME bridge is a trait to + implement over iris's parley editor, not a gap to fund upstream. It + also means E2 inherits Masonry's TODO, so a Masonry transcript will + have the same dead composer until somebody fills that in. + + **Measured on the emulator, same session, same device.** Built + android-view's own demo — `cargo ndk -t x86_64 -P 26 -o + app/src/main/jniLibs/ build -p android-view-demo --release`, then + `./gradlew :app:assembleDebug`, installed with `ANDROID_SERIAL=$(emu + serial)` — and tapped into its editor. `dumpsys input_method` reports + `mInputShown=true` with `mServedView=…viewdemo.DemoView`, and the + screenshot shows **Gboard's suggestion strip populated with "dolor | + Dolores | door"**: the caret had landed inside the word *dolor* in + the demo's lorem ipsum, and Gboard read that word out of the Rust + editor through `text_before_cursor`. So on this emulator, through + android-view, a parley editor gets a real IME with real suggestions + drawn from its own buffer. That is the bar E1 could not reach and the + bar I2 is written against, and it is now known to be reachable. + + *One crash seen once — reproduced and diagnosed 2026-09-04.* With an + accessibility client attached the app aborted, stack: `android_view::view::do_frame` → `CallbackCtx::finish` → `accesskit_android::event::QueuedEvents::raise` → `send_completed_event` → `unwrap()` on `Err(JavaException)`. android-view builds `panic = "abort"`, so a JNI call that throws takes the process. Two later `ui-trace record` runs left the app - alive, so the trigger is narrower than "a client is attached". + alive, so the trigger looked narrower than "a client is attached". + + **It is the opposite of "a client is attached": it is a client + having *detached*.** `accesskit_android`'s `State` enum + (`adapter.rs:161` in 0.4.0, `:192` in 0.8.0) is + `Inactive | Placeholder | Active`, and **nothing ever moves it back + to `Inactive`**. A client — `ui-trace`, which is uiautomator — calls + into the node provider once, `get_or_init_tree` promotes the adapter + to `Active`, and it stays there for the life of the process. Every + later change then returns `Some(QueuedEvents)`, `raise` calls + `ViewParent.requestSendAccessibilityEvent`, and that reaches + `AccessibilityManager.sendAccessibilityEvent`, which on the main + looper **throws `IllegalStateException("Accessibility off. Did you + forget to check that?")` when accessibility is disabled**. jni-rs + returns `Err(JavaException)`, `send_completed_event` unwraps it, and + `panic = "abort"` ends the process. + + *The controlled run*, one process (pid 4085), `settings get secure + accessibility_enabled` = 0 throughout: + + - tapped the editor and typed three keys with `adb shell input tap`, + no client ever attached — **alive**; + - one `ui-trace record -d 800` with no gesture at all, then two + seconds' wait — **still alive** (the queue was raised while the + client was still there); + - the very next three keystrokes, same process — **aborted**, same + stack. + + So the failure is not the recording; it is the **first thing that + changes the accessibility tree after a recording ends**. That makes + it a standing hazard for this project rather than an oddity: + `transcript-bench.sh`, `stream-bench.sh` and `bench-lib.sh`'s + tap-by-name all attach and detach uiautomator, so on a Rust app the + typing or scrolling *after* a bench run is what dies, several + seconds away from anything that looks like a cause. + + **Still present at head**: 0.8.0 is the newest `accesskit_android` + (the demo resolves 0.4.0) and both the unconditional `unwrap` in + `send_completed_event` and the one-way `State` are unchanged there, + so upgrading is not the fix. **Our mitigation for I2/I4 is a gate we + own**: ask `AccessibilityManager.isEnabled()` before calling + `raise`, and drop the events when it says no. Worth reporting + upstream as well — the honest fix is for `raise` to clear a pending + exception rather than unwrap it, since a view can be detached or + accessibility switched off between queueing and raising no matter + who is calling. *A rig trap that cost a wrong conclusion.* Several bounded runs were given `sleep N; emu down` watchdogs, and one armed for an earlier From 79b9cd789a6bd96a324cd1a59147968712ec7498 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 21:17:18 -0400 Subject: [PATCH 17/77] RUST.md: iris's bindless texture array does not survive real Android GPUs Iris asked whether the 'unknown number of images' approach even works on mobile. It does not, measured with a new rig (rigs/gpu-probe, no APK needed) and sourced rather than recalled: the emulator's software Vulkan refuses iris's descriptor-indexing request outright, and on real hardware the current Android Vulkan Profile baseline (80.1% of active devices) does not require VK_EXT_descriptor_indexing either -- Arm's own docs say only Valhall/5th-Gen Mali (2019+) support it. iris already solved the identical problem for text in I1 (the glyph atlas). The recommendation is to generalize it to images rather than widen the binding array further; not yet implemented, since it changes iris's render core. Co-Authored-By: Claude Sonnet 5 --- RUST.md | 135 +++- rigs/gpu-probe/.gitignore | 1 + rigs/gpu-probe/Cargo.lock | 1188 ++++++++++++++++++++++++++++++++++++ rigs/gpu-probe/Cargo.toml | 18 + rigs/gpu-probe/src/main.rs | 154 +++++ rigs/gpu-probe/src/vk.rs | 108 ++++ 6 files changed, 1592 insertions(+), 12 deletions(-) create mode 100644 rigs/gpu-probe/.gitignore create mode 100644 rigs/gpu-probe/Cargo.lock create mode 100644 rigs/gpu-probe/Cargo.toml create mode 100644 rigs/gpu-probe/src/main.rs create mode 100644 rigs/gpu-probe/src/vk.rs diff --git a/RUST.md b/RUST.md index 33d4a20..f36ca11 100644 --- a/RUST.md +++ b/RUST.md @@ -37,19 +37,36 @@ session spending an afternoon on them again. ## Where things stand (2026-09-04) - **Done**: E0 (toolchain), E1 (Masonry on android-view, which found the - keyboard gap), I0a, I0b (iris builds on a pinned nightly and runs), I1 - (parley + glyph atlas). -- **Next**: **I2** — iris on android-view. E1 says the first thing to - answer there is why the editor gets keystrokes but no autocorrect or - suggestions, since that is the constraint the framework decision turns - on. **E2** (a transcript in Masonry) can go in parallel in another - session. + keyboard gap — now explained, see below), I0a, I0b (iris builds on a + pinned nightly and runs), I1 (parley + glyph atlas). +- **E1's keyboard gap is Masonry's `as_input_connection` returning `None` + (a TODO), not android-view or `EditorInfo`.** android-view's own demo + implements the `InputConnection` trait over a parley editor and gets + real Gboard suggestions on this emulator — screenshotted 2026-09-04. + android-view's `accesskit_android` adapter also has a reproducible abort + (a client detaching, not attaching, is the trigger) — see E1 below for + both, with the mitigation iris/I4 needs to carry. +- **Blocking, found 2026-09-04, before I2 can be called done**: iris's + texture pipeline asks every device, unconditionally, for + `VK_EXT_descriptor_indexing` ("bindless" binding arrays) — and a + sourced check says a real share of Android hardware does not have it, + not just the emulator's software renderer. See "iris's binding array + does not survive real Android hardware" under the iris track for the + measurement, the sources, and the recommended fix (generalize the + glyph atlas to images, the same way I1 already did for text). Not yet + implemented; a design decision to confirm before iris's render core + changes. +- **Next**: decide on the atlas-based image fix above, then **I2** — + iris on android-view. **E2** (a transcript in Masonry) can go in + parallel in another session. - **Not started**: `client-core`, which is item 1 of the recommendation below and does not depend on the framework choice. Nothing has been built for it, and it is not one of the numbered boxes — worth picking up in a session that wants work independent of the emulator. -- **The app itself is untouched.** Everything so far is in `iris/` and in - the rigs; nothing under `app/` or `server/` has changed. +- **The app itself is untouched.** Everything so far is in `iris/`, in + `rigs/gpu-probe` (a headless wgpu/Vulkan feature probe, pushable to a + device with no APK — see the binding-array section), and in the other + rigs; nothing under `app/` or `server/` has changed. - **Changed outside this repo**, both in `emulator-tools` and both pushed: `avd_serial` now validates its cache by asking the device its AVD name rather than by checking the serial is still attached (a recycled port @@ -851,6 +868,97 @@ step measured. nightly gates — `portable_simd` (the old glyph compositing) and `gen_blocks` (the deleted line iterator). **Eleven left.** +### iris's binding array does not survive real Android hardware (found 2026-09-04) + +Iris asked, of the "unknown number of images" case — a transcript with an +unbounded number of attached screenshots — whether iris's approach even +works on a phone, since her recollection was that mobile does not support +it. Checked rather than assumed, and the recollection is right, with +sources rather than a guess. + +**What iris does today.** Every texture — every `Image` widget +(`src/widget/image.rs`) and every glyph atlas page — gets its own +permanent slot in one array via `Textures::add` +(`core/src/primitive/texture.rs:65`), and both the `TEXTURE` and `GLYPH` +primitives sample it by `view_idx` into `binding_array>` +at `core/src/render/shader.wgsl:56`, sized by `UiLimits::default` — 100,000 +textures, 1,000 samplers (`core/src/render/mod.rs:347`). That needs three +wgpu features: `TEXTURE_BINDING_ARRAY`, +`SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING`, +`PARTIALLY_BOUND_BINDING_ARRAY` — Vulkan's `VK_EXT_descriptor_indexing` +("bindless"), promoted to core in 1.2. So a transcript with an unbounded +number of images is exactly the case that grows this array without bound, +one permanent slot per image. + +**Measured first on the emulator, and it fails outright.** A rig +(`rigs/gpu-probe`, a plain executable with no window, pushed with `adb +push` and run from `/data/local/tmp` — no APK needed to ask a device what +it supports) asks `wgpu::Adapter::request_device` for exactly iris's +features and limits. Against the emulator's guest Vulkan — both +SwiftShader (`vk_swiftshader_icd.json`) and lavapipe (`lvp_icd.json`, +cold-booted) — `request_device` **fails**: `Unsupported features were +requested: TEXTURE_BINDING_ARRAY | +SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING | +PARTIALLY_BOUND_BINDING_ARRAY`. A second, raw query through `ash` +(`rigs/gpu-probe/src/vk.rs`, bypassing wgpu) shows lavapipe's +`vkGetPhysicalDeviceFeatures2` actually reporting all seven descriptor- +indexing sub-features as `true` at device api version 1.3 — so on this +software renderer wgpu-hal's own feature detection is being more +conservative than the driver, for a reason not chased further (a likely +instance-version negotiation gap, since `VK_EXT_descriptor_indexing` was +only promoted to core at 1.2 and wgpu-hal's own `Instance::init` may be +requesting less). That part is an emulator/wgpu-hal question and not the +finding that matters. + +**The finding that matters is about real phones, not the emulator, and it +is sourced rather than recalled.** The **Android Vulkan Profile 2025** — +Google and Khronos's current baseline, covering **80.1% of active +Vulkan-capable Android devices** as of October 2025 +([developer.android.com/ndk/guides/graphics/android-vulkan-profile](https://developer.android.com/ndk/guides/graphics/android-vulkan-profile)) +— does **not** require `VK_EXT_descriptor_indexing` or any descriptor- +indexing feature. It requires `shaderSampledImageArrayDynamicIndexing` +(indexing an array of samplers by a value uniform across the invocation — +Vulkan 1.0 baseline, unrelated to bindless) and stops there; the same is +true of the 2021 and 2022 profiles. On the hardware side, Arm's own +developer documentation states **"`VK_EXT_descriptor_indexing` is +supported on all Valhall and 5th Gen GPUs"** +([developer.arm.com/mobile-graphics-and-gaming/vulkan-api-best-practices-on-arm-gpus](https://developer.arm.com/mobile-graphics-and-gaming/vulkan-api-best-practices-on-arm-gpus)) — +Mali generations from roughly 2019 (Mali-G77) onward, named affirmatively +with no claim made for Bifrost, Midgard or Utgard, which are still common +in budget and older Android phones still in use. So this is not a +software-renderer artifact: a real, currently-shipping share of the +Android fleet lacks the feature iris's texture pipeline asks for +unconditionally, and the newest official baseline does not promise it +either. (A crates.io/search-engine claim of "1% support on Android" for +this extension was checked against its cited source, an Arm blog post, +and was not actually there — that number does not appear anywhere primary +and should not be repeated; the 80.1%-baseline-excludes-it finding above +is the one with an attributable source.) + +**Recommendation, not yet implemented.** iris already solved the +identical problem for text in I1: the glyph atlas +(`core/src/render/atlas.rs`) packs many small rasters into a handful of +shared 1024×1024 pages and samples them by UV offset, so **text needs +none of the three features above** — only ordinary single-texture +sampling. The same technique generalizes to images: route an `Image` +widget through a shared atlas when it is small enough to pack (thumbnails, +downscaled attachment previews, avatars, icons), and fall back to one +ordinary, non-array texture bind group — selected per batched draw call +the way every immediate-mode 2D renderer already does — for anything too +large to atlas well (a photo opened at full resolution). Either path is +plain Vulkan 1.0 / GLES texture sampling, so it removes the descriptor- +indexing requirement from iris's device request entirely, which is also +what would make the emulator work regardless of the wgpu-hal question +above: a device that never asks for the feature cannot be refused for +lacking it. This is a change to iris's rendering core — the shader's +binding group layout, `Textures`, the texture and glyph primitives, and +`ui/painter.rs` — so it is written here as a recommendation rather than +started, per the project's rule to confirm a load-bearing design change +before making it. **It should be resolved before I2 is called done**, +since I2's pass condition is the phone, not just the emulator, and this +is exactly the kind of thing that passes on a desktop GPU and fails +silently on real hardware. + - [ ] **I2 — iris on android-view.** An `android-view` surface as a second backend beside winit: `wgpu` on the view's surface (GLES here, see the Vulkan section; Vulkan on the phone), touch as pointer events, @@ -895,9 +1003,12 @@ re-derived: 5. Run the existing rigs rather than inventing new ones: `ui-sandbox.sh` for a server with fixtures, `transcript-bench.sh` for the scroll baseline, `ui-trace` for anything positional, `emu up` for the - emulator, and `iris/run-headless.sh EXAMPLE --shot PNG` for an iris - example on this displayless machine. The Vulkan section below says how - to get a Vulkan path in the emulator when a `wgpu` backend needs one. + emulator, `iris/run-headless.sh EXAMPLE --shot PNG` for an iris + example on this displayless machine, and `rigs/gpu-probe` to ask a + device (this VM, the emulator, or a real phone over `adb push`) what + `wgpu` features and limits it actually has before building anything on + the assumption it does. The Vulkan section below says how to get a + Vulkan path in the emulator when a `wgpu` backend needs one. 6. **Bound anything heavy at the moment you start it.** An emulator or a long build gets a deadline — `timeout`, or a watchdog scoped to the pid you just started — rather than a plan to stop it later. Scope it to diff --git a/rigs/gpu-probe/.gitignore b/rigs/gpu-probe/.gitignore new file mode 100644 index 0000000..eb5a316 --- /dev/null +++ b/rigs/gpu-probe/.gitignore @@ -0,0 +1 @@ +target diff --git a/rigs/gpu-probe/Cargo.lock b/rigs/gpu-probe/Cargo.lock new file mode 100644 index 0000000..f7e41e2 --- /dev/null +++ b/rigs/gpu-probe/Cargo.lock @@ -0,0 +1,1188 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "android_system_properties" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" +dependencies = [ + "libc", +] + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "ash" +version = "0.38.0+1.3.281" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" +dependencies = [ + "libloading", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bitflags" +version = "2.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da" + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0e56a716f1e132ff6bf4bdac1c944a3fcdc1cae65f70a4a2a1ac3b401d2d1f" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "codespan-reporting" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81" +dependencies = [ + "serde", + "termcolor", + "unicode-width", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics-types" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb" +dependencies = [ + "bitflags", + "core-foundation", + "libc", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "gl_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d" +dependencies = [ + "khronos_api", + "log", + "xml-rs", +] + +[[package]] +name = "glow" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5e5ea60d70410161c8bf5da3fdfeaa1c72ed2c15f8bbb9d19fe3a4fad085f08" +dependencies = [ + "js-sys", + "slotmap", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "glutin_wgl_sys" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c4ee00b289aba7a9e5306d57c2d05499b2e5dc427f84ac708bd2c090212cf3e" +dependencies = [ + "gl_generator", +] + +[[package]] +name = "gpu-allocator" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795" +dependencies = [ + "ash", + "hashbrown 0.16.1", + "log", + "presser", + "thiserror", + "windows", +] + +[[package]] +name = "gpu-descriptor" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca" +dependencies = [ + "bitflags", + "gpu-descriptor-types", + "hashbrown 0.15.5", +] + +[[package]] +name = "gpu-descriptor-types" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91" +dependencies = [ + "bitflags", +] + +[[package]] +name = "gpu-probe" +version = "0.1.0" +dependencies = [ + "ash", + "pollster", + "wgpu", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "hexf-parse" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" + +[[package]] +name = "indexmap" +version = "2.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07aa2048142242915a31d35844fb311e0e53fcca590c3a0a40dcf1b841fa09eb" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "js-sys" +version = "0.3.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "khronos-egl" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76" +dependencies = [ + "libc", + "libloading", + "pkg-config", +] + +[[package]] +name = "khronos_api" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" + +[[package]] +name = "libc" +version = "0.2.189" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "metal" +version = "0.33.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7047791b5bc903b8cd963014b355f71dc9864a9a0b727057676c1dcae5cbc15" +dependencies = [ + "bitflags", + "block", + "core-graphics-types", + "foreign-types", + "log", + "objc", + "paste", +] + +[[package]] +name = "naga" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "618f667225063219ddfc61251087db8a9aec3c3f0950c916b614e403486f1135" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown 0.16.1", + "hexf-parse", + "indexmap", + "libm", + "log", + "num-traits", + "once_cell", + "rustc-hash", + "spirv", + "thiserror", + "unicode-ident", +] + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys 0.3.1", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "ordered-float" +version = "5.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c7c9e0d9b23589f26070720bac724174bfec1083e82f7854cdd0267518343c0" +dependencies = [ + "num-traits", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-link", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "pollster" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "presser" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "range-alloc" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags", +] + +[[package]] +name = "renderdoc-sys" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", +] + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9be42f50aa861c555654aa3a37f52f4b1074bacf4e48fe0ef7fa584e80f1f0f" + +[[package]] +name = "spirv" +version = "0.3.0+sdk-1.3.268.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" +dependencies = [ + "bitflags", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.5", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasm-bindgen" +version = "0.2.127" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b7777d5cc23d0e91404e53ce2d5e8ec7acae3026b16233dba62cd3246457950" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.127" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.127" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 2.0.119", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.127" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "web-sys" +version = "0.3.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "wgpu" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9cb534d5ffd109c7d1135f34cdae29e60eab94855a625dcfe1705f8bc7ad79f" +dependencies = [ + "arrayvec", + "bitflags", + "bytemuck", + "cfg-if", + "cfg_aliases", + "document-features", + "hashbrown 0.16.1", + "js-sys", + "log", + "naga", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "28.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d23f4642f53f666adcfd2d3218ab174d1e6681101aef18696b90cbe64d1c10f9" +dependencies = [ + "arrayvec", + "bit-set", + "bit-vec", + "bitflags", + "bytemuck", + "cfg_aliases", + "document-features", + "hashbrown 0.16.1", + "indexmap", + "log", + "naga", + "once_cell", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "rustc-hash", + "smallvec", + "thiserror", + "wgpu-core-deps-apple", + "wgpu-core-deps-emscripten", + "wgpu-core-deps-windows-linux-android", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core-deps-apple" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87b7b696b918f337c486bf93142454080a32a37832ba8a31e4f48221890047da" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-emscripten" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34b251c331f84feac147de3c4aa3aa45112622a95dd7ee1b74384fa0458dbd79" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-windows-linux-android" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ca976e72b2c9964eb243e281f6ce7f14a514e409920920dcda12ae40febaae" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-hal" +version = "28.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d6cb474beb218824dcc9e1ce679d973f719262789bfb27407da560cac20eeb" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bit-set", + "bitflags", + "block", + "bytemuck", + "cfg-if", + "cfg_aliases", + "core-graphics-types", + "glow", + "glutin_wgl_sys", + "gpu-allocator", + "gpu-descriptor", + "hashbrown 0.16.1", + "js-sys", + "khronos-egl", + "libc", + "libloading", + "log", + "metal", + "naga", + "ndk-sys", + "objc", + "once_cell", + "ordered-float", + "parking_lot", + "portable-atomic", + "portable-atomic-util", + "profiling", + "range-alloc", + "raw-window-handle", + "renderdoc-sys", + "smallvec", + "thiserror", + "wasm-bindgen", + "web-sys", + "wgpu-types", + "windows", + "windows-core", +] + +[[package]] +name = "wgpu-types" +version = "28.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e18308757e594ed2cd27dddbb16a139c42a683819d32a2e0b1b0167552f5840c" +dependencies = [ + "bitflags", + "bytemuck", + "js-sys", + "log", + "web-sys", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "xml-rs" +version = "0.8.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7" + +[[package]] +name = "zerocopy" +version = "0.8.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] diff --git a/rigs/gpu-probe/Cargo.toml b/rigs/gpu-probe/Cargo.toml new file mode 100644 index 0000000..bc6fc8d --- /dev/null +++ b/rigs/gpu-probe/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "gpu-probe" +version = "0.1.0" +edition = "2024" + +# Deliberately its own crate rather than a member of iris's workspace: the +# vendored `iris/` tree is meant to stay reconcilable with the iris/iris +# repository, and this is a rig belonging to ai-app. + +[dependencies] +# Pinned to what iris asks for, so the answer is about iris rather than +# about a different wgpu. +wgpu = "28.0.0" +pollster = "0.4.0" +# Queried directly, because wgpu and `cmd gpu vkjson` disagreed about +# descriptor indexing in the emulator and only the raw call says which is +# right. +ash = "0.38" diff --git a/rigs/gpu-probe/src/main.rs b/rigs/gpu-probe/src/main.rs new file mode 100644 index 0000000..1643e6b --- /dev/null +++ b/rigs/gpu-probe/src/main.rs @@ -0,0 +1,154 @@ +//! Ask a device whether it can give iris the GPU it asks for. +//! +//! iris's renderer binds every texture it has drawn as one binding array and +//! indexes it non-uniformly from the shader, which needs descriptor indexing +//! and a very large per-stage binding-array limit (101,000 elements: 100,000 +//! textures and 1,000 samplers, `UiLimits::default`). Those are ordinary on a +//! desktop and not obviously available on a phone, so this reports what the +//! adapter offers before anything is built on the assumption. +//! +//! It runs as a plain executable with no window and no APK, because +//! `request_adapter` needs no surface -- so it can be pushed to a device with +//! `adb push` and run from `/data/local/tmp`, which is far cheaper than an +//! app. What it therefore cannot answer is anything about presenting to a +//! surface; that is the Android backend's own problem. + +mod vk; + +use wgpu::*; + +/// What `iris/src/default/render.rs` asks `request_device` for. +fn iris_features() -> Features { + Features::TEXTURE_BINDING_ARRAY + | Features::PARTIALLY_BOUND_BINDING_ARRAY + | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING +} + +/// `UiLimits::default()`: 100,000 textures + 1,000 samplers. +const IRIS_MAX_BINDING_ARRAY: u32 = 101_000; +const IRIS_MAX_BINDING_ARRAY_SAMPLERS: u32 = 1_000; + +fn main() { + vk::report(); + + let instance = Instance::new(&InstanceDescriptor { + backends: Backends::from_env().unwrap_or(Backends::PRIMARY), + ..Default::default() + }); + + let adapters = pollster::block_on(instance.enumerate_adapters(Backends::all())); + println!("adapters: {}", adapters.len()); + for adapter in &adapters { + let info = adapter.get_info(); + println!( + " {:?} {} ({:?})", + info.backend, info.name, info.device_type + ); + } + + let Some(adapter) = pollster::block_on(instance.request_adapter(&RequestAdapterOptions { + power_preference: PowerPreference::default(), + compatible_surface: None, + force_fallback_adapter: false, + })) + .ok() else { + println!("\nNO ADAPTER"); + std::process::exit(1); + }; + + let info = adapter.get_info(); + println!( + "\nchosen: {:?} {} ({:?})", + info.backend, info.name, info.device_type + ); + println!("driver: {} {}", info.driver, info.driver_info); + + let have = adapter.features(); + println!("\nfeatures iris requires:"); + let mut missing = Features::empty(); + for f in iris_features().iter() { + let ok = have.contains(f); + println!( + " {:60} {}", + format!("{f:?}"), + if ok { "yes" } else { "NO" } + ); + if !ok { + missing |= f; + } + } + + let limits = adapter.limits(); + println!("\nlimits iris requires:"); + for (name, want, got) in [ + ( + "max_binding_array_elements_per_shader_stage", + IRIS_MAX_BINDING_ARRAY, + limits.max_binding_array_elements_per_shader_stage, + ), + ( + "max_binding_array_sampler_elements_per_shader_stage", + IRIS_MAX_BINDING_ARRAY_SAMPLERS, + limits.max_binding_array_sampler_elements_per_shader_stage, + ), + ] { + println!( + " {name:52} want {want:>7} have {got:>7} {}", + if got >= want { "ok" } else { "TOO SMALL" } + ); + } + println!( + " {:52} want {:>7} have {:>7}", + "max_buffer_size (iris asks 1<<30)", + 1u64 << 30, + limits.max_buffer_size + ); + + // The question that actually matters: does the device iris builds come + // back, or does wgpu refuse it? + let mut wanted = Limits { + max_binding_array_elements_per_shader_stage: IRIS_MAX_BINDING_ARRAY, + max_binding_array_sampler_elements_per_shader_stage: IRIS_MAX_BINDING_ARRAY_SAMPLERS, + max_buffer_size: 1 << 30, + ..Default::default() + }; + match pollster::block_on(adapter.request_device(&DeviceDescriptor { + required_features: iris_features(), + required_limits: wanted.clone(), + ..Default::default() + })) { + Ok(_) => println!("\nIRIS DEVICE: ok"), + Err(e) => println!("\nIRIS DEVICE: FAILED -- {e}"), + } + + // If it failed, say how far down it has to be turned before it works, so + // the report names a number to design against rather than just "no". + if missing.is_empty() { + for cap in [ + limits.max_binding_array_elements_per_shader_stage, + 1024, + 128, + 16, + ] { + if cap >= IRIS_MAX_BINDING_ARRAY { + continue; + } + wanted.max_binding_array_elements_per_shader_stage = cap; + wanted.max_binding_array_sampler_elements_per_shader_stage = + cap.min(IRIS_MAX_BINDING_ARRAY_SAMPLERS); + let ok = pollster::block_on(adapter.request_device(&DeviceDescriptor { + required_features: iris_features(), + required_limits: wanted.clone(), + ..Default::default() + })) + .is_ok(); + println!( + " binding array capped at {cap:>7}: {}", + if ok { "ok" } else { "no" } + ); + if ok { + break; + } + } + } +} diff --git a/rigs/gpu-probe/src/vk.rs b/rigs/gpu-probe/src/vk.rs new file mode 100644 index 0000000..0d4ec6a --- /dev/null +++ b/rigs/gpu-probe/src/vk.rs @@ -0,0 +1,108 @@ +//! The raw Vulkan half of the probe. +//! +//! wgpu reports a feature only after a chain of its own decisions -- which +//! physical device, which API version, which extension list -- so "wgpu says +//! no" and "the driver says no" are different claims. This asks +//! `vkGetPhysicalDeviceFeatures2` itself and prints the inputs to that chain, +//! so a disagreement can be attributed rather than guessed at. + +use ash::{Entry, vk}; +use std::ffi::CStr; + +pub fn report() { + let entry = match unsafe { Entry::load() } { + Ok(e) => e, + Err(e) => { + println!("\nraw vulkan: cannot load loader -- {e}"); + return; + } + }; + + let instance_version = match unsafe { entry.try_enumerate_instance_version() } { + Ok(Some(v)) => v, + Ok(None) => vk::API_VERSION_1_0, + Err(e) => { + println!("\nraw vulkan: enumerate_instance_version failed -- {e}"); + return; + } + }; + println!("\nraw vulkan:"); + println!(" loader instance version: {}", ver(instance_version)); + + // Ask for the highest instance version the loader admits to: wgpu clamps + // the device version by the instance's, so an instance created at 1.0 + // makes a 1.3 device look like 1.0. + let app_info = vk::ApplicationInfo::default().api_version(instance_version); + let create = vk::InstanceCreateInfo::default().application_info(&app_info); + let instance = match unsafe { entry.create_instance(&create, None) } { + Ok(i) => i, + Err(e) => { + println!(" create_instance failed -- {e}"); + return; + } + }; + + let devices = unsafe { instance.enumerate_physical_devices() }.unwrap_or_default(); + for phd in devices { + let props = unsafe { instance.get_physical_device_properties(phd) }; + let name = unsafe { CStr::from_ptr(props.device_name.as_ptr()) }; + println!(" device: {}", name.to_string_lossy()); + println!(" device api version: {}", ver(props.api_version)); + + let exts = + unsafe { instance.enumerate_device_extension_properties(phd) }.unwrap_or_default(); + let has_ext = exts.iter().any(|e| { + (unsafe { CStr::from_ptr(e.extension_name.as_ptr()) }) == c"VK_EXT_descriptor_indexing" + }); + println!(" VK_EXT_descriptor_indexing advertised: {has_ext}"); + println!(" device extensions: {}", exts.len()); + + let mut indexing = vk::PhysicalDeviceDescriptorIndexingFeatures::default(); + let mut features2 = vk::PhysicalDeviceFeatures2::default().push_next(&mut indexing); + unsafe { instance.get_physical_device_features2(phd, &mut features2) }; + + for (name, v) in [ + ( + "shaderSampledImageArrayNonUniformIndexing", + indexing.shader_sampled_image_array_non_uniform_indexing, + ), + ( + "descriptorBindingSampledImageUpdateAfterBind", + indexing.descriptor_binding_sampled_image_update_after_bind, + ), + ( + "shaderStorageImageArrayNonUniformIndexing", + indexing.shader_storage_image_array_non_uniform_indexing, + ), + ( + "descriptorBindingStorageImageUpdateAfterBind", + indexing.descriptor_binding_storage_image_update_after_bind, + ), + ( + "shaderStorageBufferArrayNonUniformIndexing", + indexing.shader_storage_buffer_array_non_uniform_indexing, + ), + ( + "descriptorBindingStorageBufferUpdateAfterBind", + indexing.descriptor_binding_storage_buffer_update_after_bind, + ), + ( + "descriptorBindingPartiallyBound", + indexing.descriptor_binding_partially_bound, + ), + ] { + println!(" {name:48} {}", if v != 0 { "yes" } else { "NO" }); + } + } + + unsafe { instance.destroy_instance(None) }; +} + +fn ver(v: u32) -> String { + format!( + "{}.{}.{}", + vk::api_version_major(v), + vk::api_version_minor(v), + vk::api_version_patch(v) + ) +} From 6e49ce8c925dfafda3b73e7c28dd719a8c7de021 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 21:36:56 -0400 Subject: [PATCH 18/77] TEXTURES.md: how iris should render an unbounded number of images Written for review before iris's render core changes. Covers the bindless binding-array problem, the gpu-probe measurements (emulator and sourced real-hardware findings), what growth already costs today in the current code, the egui_wgpu/Vello prior art, and the recommendation with its open questions -- not yet implemented. Co-Authored-By: Claude Sonnet 5 --- TEXTURES.md | 215 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 TEXTURES.md diff --git a/TEXTURES.md b/TEXTURES.md new file mode 100644 index 0000000..1f9448d --- /dev/null +++ b/TEXTURES.md @@ -0,0 +1,215 @@ +# How iris should render an unbounded number of images + +Iris (the person) asked whether iris's (the library's) approach to +"draw however many images happen to be on screen" — relevant here because a +transcript can hold an unbounded number of attached screenshots — actually +works on mobile, her recollection being that it does not. Checked rather +than assumed, on 2026-09-04, on the `rustify` branch of `ai-app-2`. This +file is that investigation and the resulting recommendation, written for a +second agent to review before anything in iris's render core changes — no +code has been written against this yet. + +## The problem + +Every texture iris ever creates — every `Image` widget +(`iris/src/widget/image.rs`) and every glyph atlas page — gets a permanent +slot in one array via `Textures::add` (`iris/core/src/primitive/texture.rs:65`). +Both of iris's texture-sampling primitives (`TEXTURE` and `GLYPH`) read that +array by index: `core/src/render/shader.wgsl:56` declares +`var views: binding_array>`, sized by +`UiLimits::default()` (`core/src/render/mod.rs:347`) at **100,000 textures, +1,000 samplers**. Getting a device to accept that layout needs three wgpu +features — `TEXTURE_BINDING_ARRAY`, +`SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING`, +`PARTIALLY_BOUND_BINDING_ARRAY` — which correspond to Vulkan's +`VK_EXT_descriptor_indexing` ("bindless"), promoted to Vulkan core at 1.2. + +A transcript with an unbounded number of image attachments is exactly the +case that grows this array without bound: each attachment becomes its own +`Image` widget, which takes its own permanent array slot until dropped. + +## What was measured + +**A new rig, `rigs/gpu-probe`**, asks a device for exactly iris's features +and limits with no window and no APK — a plain executable pushed with +`adb push` and run from `/data/local/tmp`. It has two parts: +`wgpu::Adapter::request_device` with iris's exact `Features`/`Limits` +(`src/main.rs`), and a raw Vulkan query bypassing wgpu entirely via `ash` +(`src/vk.rs`), to tell "the driver doesn't have it" apart from "wgpu didn't +detect it." + +- **On this VM's own GPU** (Vulkan via Venus onto an RX 7900 XT): + `IRIS DEVICE: ok`. Not the case that matters — nobody's phone is a + discrete desktop GPU — but it is why the design was never checked before + now: it always worked in the one place it was tried. +- **On the Android emulator's guest Vulkan**, both ICDs it ships + (`vk_swiftshader_icd.json` and, cold-booted, `lvp_icd.json`/lavapipe): + `request_device` **fails** — + `Unsupported features were requested: TEXTURE_BINDING_ARRAY | + SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING | + PARTIALLY_BOUND_BINDING_ARRAY`. The raw `ash` query on lavapipe shows the + driver itself reporting all seven descriptor-indexing sub-features as + `true` at device API version 1.3 — so wgpu-hal's own feature detection is + being more conservative than the driver here, for a reason not chased + further (a likely instance-version negotiation gap, since the extension + only promoted to core at 1.2). That part is a wgpu-hal/emulator question, + not the finding that matters, and is **not** why this design is rejected. + +**The finding that matters is about real phones, sourced rather than +recalled:** + +- The **Android Vulkan Profile 2025** — Google and Khronos's current + baseline, covering **80.1% of active Vulkan-capable Android devices** as + of October 2025 + ([developer.android.com/ndk/guides/graphics/android-vulkan-profile](https://developer.android.com/ndk/guides/graphics/android-vulkan-profile)) — + does **not** require `VK_EXT_descriptor_indexing` or any descriptor- + indexing feature. It requires `shaderSampledImageArrayDynamicIndexing` + (indexing by a value uniform across the invocation — Vulkan 1.0 baseline, + unrelated to bindless) and stops there; true of the 2021 and 2022 + profiles as well. +- Arm's own developer documentation states **"`VK_EXT_descriptor_indexing` + is supported on all Valhall and 5th Gen GPUs"** + ([developer.arm.com/mobile-graphics-and-gaming/vulkan-api-best-practices-on-arm-gpus](https://developer.arm.com/mobile-graphics-and-gaming/vulkan-api-best-practices-on-arm-gpus)) — + Mali generations from roughly 2019 (Mali-G77) onward, with no claim made + for Bifrost, Midgard or Utgard, which are still common in budget and + older Android phones that are still in daily use. +- A search engine's summarized claim of "1% support on Android" for this + extension was checked against its cited source (an Arm blog post from + 2021) and **was not actually there** — that number does not appear in + any primary source found and should not be repeated. The baseline- + profile finding above is the one with an attributable source; use it + instead. + +So this is not a software-renderer artifact. A real, currently-shipping +share of the Android fleet lacks the feature iris's texture pipeline asks +for unconditionally, and neither the emulator's failure nor the current +official hardware baseline gives any reason to expect that to change soon. + +## What growth already costs today, before any redesign + +Checked directly in `core/src/render/mod.rs` and `core/src/render/texture.rs`, +because "does this redesign make things worse" needs the current baseline +first: + +- The `RenderPipeline` (`UiRenderNode::new`) is created **once** and never + rebuilt for any reason related to texture count — its bind group + *layouts* declare fixed slot counts (`limits.max_textures`, + `limits.max_samplers`) up front and that never changes at runtime. Growth + was never at risk of recreating the pipeline, in the current design or + any redesign discussed below. +- What **does** get rebuilt: `UiRenderNode::update` calls + `self.textures.update(&mut ui.textures)`, and if that reports any change, + rebuilds `self.rsc_group` — one `BindGroup` whose entries are + `BindingResource::TextureViewArray(&tex_manager.views())`, collected + fresh over **every currently-live texture**, plus the sampler array and + the mask buffer. This happens on every texture `Push`, `Set`, or `Free` + — an image added anywhere in the whole app rebuilds one shared structure + referencing every other image too. +- The one path already excluded from this, on purpose, is a `Patch` — + writing into an existing texture's pixels without changing which + textures exist. The code says why directly + (`core/src/render/texture.rs`, in `GpuTextures::update`): *"A patch + changes texture contents, not the binding array, so it must not report + `changed` — rebuilding the bind group per glyph is the cost this exists + to avoid."* This is exactly the mechanism I1 built for the glyph atlas: + growing an existing atlas page costs a `write_texture` into a sub-rect, + nothing else. + +So today, growth that stays inside an existing texture (glyphs added to an +atlas page) is already free. Growth that adds a *new* texture — a new atlas +page, or any standalone image — already rebuilds the one shared array +regardless of how the array is populated, before any change discussed +below. That existing cost is O(live texture count) in CPU work to collect +the view list and in however expensive the driver finds a +descriptor-set-sized-for-N-descriptors to be. + +## Prior art, checked rather than assumed + +Two independent projects were checked to see whether "atlas for images" +is actually how this is normally done, rather than a guess: + +- **egui_wgpu** (`crates/egui-wgpu/src/renderer.rs` in emilk/egui), the + closest prior art to iris — an immediate-mode wgpu-backed UI library that + ships on Android. It keeps a `HashMap` and gives + **each texture its own ordinary `BindGroup`** — one texture, one sampler, + no array, no descriptor indexing of any kind. Draw calls are batched by + texture id and the bind group is switched between batches within the + render pass. +- **Vello** — the renderer Masonry (E1/E2's Linebender stack) draws + through — hit the identical problem and wrote down why in their own + roadmap document + ([github.com/linebender/vello/blob/main/doc/roadmap_2023.md](https://github.com/linebender/vello/blob/main/doc/roadmap_2023.md)): + *"The number of images that may appear in a scene is not bounded, which + is not a good fit for the basic descriptor binding model... Until then, + we'll do a workaround of having a single atlas image containing all the + images in the scene."* Their reason is broader than Android — WebGPU 1.0 + has no descriptor indexing at all — but it reaches the same conclusion + for the same shape of problem: atlas, not a bigger bindless array. + +**This is also a live hazard, not a solved one.** Vello's own changelog +(Sparse Strips v0.2.0) lists a fix titled *"WebGL image-atlas allocation +and growth on Mali-G52 GPUs, avoiding application-not-responding errors"* +— an actual ANR, from atlas growth, on an actual mid-range Android GPU, +in the renderer Masonry is built on. The same release added +`AtlasSpaceDiagnostics`/`AtlasLayerDiagnostics` (per-layer free-space, +utilization, fragmentation) because growth needed instrumenting in +production, not because it turned out to be free. + +## Recommendation (not yet implemented) + +1. **Small, plentiful textures** — glyphs (already done, I1), thumbnails, + downscaled attachment previews, icons — go through a shared atlas, the + same technique as `core/src/render/atlas.rs` generalized beyond glyphs. + Adding one to an existing page is a `Patch`, already free per the + section above. +2. **Large or one-off images** — a photo attachment opened at full + resolution, anything that would fragment a shared page — get their + **own ordinary, non-array bind group**, the egui_wgpu way. Creating one + is O(1): it references only itself, and does not touch any other + texture's binding, unlike today's shared array where every push + rebuilds a structure listing everything. +3. **Opening a new atlas page** is the one case that still resembles + today's rebuild — infrequent (bounded by how many *pages* are needed, + not by how many images have ever been attached) but not free, and + Vello's Mali-G52 fix says this specifically deserves care: it should + never be allowed to block a frame, and it is worth having the + equivalent of Vello's atlas diagnostics before trusting it under load. +4. **Net effect**: dropping `TEXTURE_BINDING_ARRAY`, + `SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING`, and + `PARTIALLY_BOUND_BINDING_ARRAY` from iris's device request entirely. + Every path above is plain Vulkan 1.0 / GLES-level texture sampling. + This is also what fixes the emulator failure measured above, regardless + of the unresolved wgpu-hal question: a device that never asks for the + feature cannot be refused for lacking it. + +## What this touches, and what is still open + +Implementing this reworks iris's rendering core: the shader's binding +group layout (`shader.wgsl`), `Textures` and `GpuTextures` +(`core/src/primitive/texture.rs`, `core/src/render/texture.rs`), both +texture-sampling primitives, and `core/src/ui/painter.rs`'s draw-call +batching (today one draw call can reference any texture by index; the +per-texture-bind-group path needs draws grouped by which bind group they +use). Nothing has been started. + +Open questions a reviewer should weigh in on: + +- **The size threshold** between "goes in an atlas page" and "gets its own + bind group." Too low and ordinary attachment thumbnails end up as + one-off bind groups, losing the batching benefit the atlas exists for; + too high and a page fragments on a handful of medium images. +- **Eviction policy** for atlas pages once the working set does not fit — + today's `GlyphAtlas` never evicts, because a font's glyph set is small + and bounded; images are not. An LRU at the page level, or at the + individual-image level within a page, has not been designed. +- **Whether iris should keep any binding array at all**, even a small + fixed one (say, capped at a few dozen slots) for atlas pages themselves, + or whether every atlas page should also be its own ordinary bind group + like standalone images — the array's only remaining justification would + be avoiding a bind-group-per-draw-call switch cost that has not been + measured on this project's actual target hardware. +- **How this interacts with I2/E2's virtualised list** (I3): a + bottom-anchored transcript composes only visible rows, so the live + texture set should already be bounded by what is on screen rather than + by the whole conversation — worth confirming that invariant holds before + relying on it to keep atlas/bind-group churn small. From 4400966928e2bd74d468b95514ce37ce96bc1628 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 21:49:41 -0400 Subject: [PATCH 19/77] TEXTURES.md: review -- wgpu-hal gate located, a Patch-cancels-Push bug, and a sort-free shape Co-Authored-By: Claude Fable 5.1 --- TEXTURES.md | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) diff --git a/TEXTURES.md b/TEXTURES.md index 1f9448d..e38e5df 100644 --- a/TEXTURES.md +++ b/TEXTURES.md @@ -213,3 +213,123 @@ Open questions a reviewer should weigh in on: texture set should already be bounded by what is on screen rather than by the whole conversation — worth confirming that invariant holds before relying on it to keep atlas/bind-group churn small. + +## Review, 2026-09-04 + +A second pass over the file above against the code, done before anything +is implemented. Iris's worry going in: a bind group per texture means a +draw call per image, and she wants this as efficient as it can be. + +### What checked out + +Every code reference above is accurate as of this commit: the 100,000 / +1,000 limits, the one-time pipeline, the `rsc_group` rebuild on every +`Push`/`Set`/`Free`, and the `Patch` exclusion. The device request that +asks for the three features is `iris/src/default/render.rs:96`, which the +text above does not name. egui-wgpu and Vello are described correctly. + +### The emulator refusal is a wgpu-hal gap, now located + +The file guessed "a likely instance-version negotiation gap." It is +narrower than that and it is in wgpu-hal, not the emulator. wgpu-hal +28.0.0 (`src/vulkan/adapter.rs:1618`) only queries +`PhysicalDeviceDescriptorIndexingFeaturesEXT` **when the device advertises +the `VK_EXT_descriptor_indexing` extension string**. A Vulkan 1.2+ driver +that has descriptor indexing as core need not list the extension, and +lavapipe at 1.3 evidently does not, so wgpu never asks and reports the +features absent, which is why `ash` sees seven `true`s and wgpu sees none. +The properties query beside it (line 1486) correctly accepts +`device_api_version >= 1.2 || extension`; the features query does not. +wgpu-hal 30.0.1 in the local registry has the same asymmetry (lines +1872 and 2036). Worth an upstream issue, but not a reason to keep the +design: on real phones the gate that matters is stricter still. + +**wgpu's `TEXTURE_BINDING_ARRAY` needs six sub-features, not one** +(`adapter.rs:160-177`): non-uniform indexing *and* update-after-bind for +sampled images, storage images and storage buffers, all together, because +wgpu marks every array-bearing descriptor set update-after-bind. So Arm's +"the extension is supported on Valhall" is necessary but not sufficient; +a driver with sampled-image indexing and without storage-buffer +update-after-bind is refused too. That widens the excluded set beyond +what the Arm quote suggests and strengthens the conclusion. + +### A live bug in the current code, found on the way + +`GpuTextures::update` (`core/src/render/texture.rs:33`) implements +"a patch must not report changed" as `changed = false`, unconditionally, +which also **cancels a `Push` earlier in the same batch**. That ordering is +exactly what opening a new atlas page produces: `GlyphAtlas::allocate` +pushes the page and `insert` patches it in the same frame, so the bind +group is not rebuilt and the new page's view is not bound until some +unrelated texture change happens to rebuild it. It is hidden today only +because the masks path also sets `changed`. The fix is one line +(`changed |= !matches!(update, Patch)` in spirit); it should go in with +the redesign since that code is being replaced, and it is recorded here +so it is not rediscovered. + +### In-layer draw order is already undefined + +Relevant to any batching redesign: `Primitives::apply_free` +(`core/src/render/primitive.rs:147`) uses `swap_remove`, so the instance +order within a layer is permuted whenever anything is freed. Overlap order +inside one layer is therefore not something the renderer promises today; +ordering is done with layers. That means grouping a layer's draws by +texture, or drawing a layer's images after its rects and glyphs, loses +nothing that currently exists. It should be written down as an invariant +when the redesign lands, because the new code will depend on it. + +### On "a draw call per image" + +Two corrections to the worry. First, it is a draw per *distinct texture per +layer*, not per image primitive: every glyph quad in a layer shares the +atlas and stays one instanced draw, and a thumbnail atlas would do the same +for previews. Second, the count is bounded by what is on screen, which I3's +virtualised transcript already bounds, and a mobile GPU is not draw-call +bound at tens of draws per frame; egui ships exactly this on Android. What +does cost is per-frame *bind group creation* and per-frame *sorting*, and +the current code already creates a `primitive_group` bind group every time +a layer updates (`render/mod.rs:103`), so one more per new image is not a +regression in kind. + +### Recommended shape (proposal, for Iris to accept or change) + +Aimed at the fewest moving parts that need no feature beyond Vulkan 1.0: + +1. **Atlas pages become layers of one `texture_2d_array`**, not separate + textures. Every page is already `PAGE`x`PAGE` RGBA8, which is the one + constraint an array texture imposes. A layer index is an ordinary + sampling operand in WGSL and needs no indexing feature, so `GLYPH` + (and any future atlased-image primitive) carries a layer instead of a + `view_idx` and all of a layer's text stays **one draw**. This answers + the open question above about keeping a small binding array: no. Cost + of opening a page: recreate the array with one more layer and + `copy_texture_to_texture` the old ones, GPU-side, no readback; grow + with headroom (double) so it is rare. wgpu's default + `max_texture_array_layers` is 256, at 4 MB each, so the cap is memory + rather than the API. +2. **Every standalone image is its own texture with its own bind group**, + and its instances live in a **separate per-layer instance list**, not + the main one. Then the main instance buffer never contains an image, + there is nothing to sort, no handle remapping beyond what + `apply_free` already does, and each image is `draw(0..4, k..k+1)` with + its bind group set first. Group 2's layout becomes `{atlas array, + one image texture, sampler, masks}`; the main draw binds a 1x1 null + image in the image slot, each image draw binds its own. One pipeline, + one shader, one layout. +3. **No thumbnail atlas in the first version.** With images on their own + textures, the threshold and eviction questions above disappear: an + image is freed when the row that owns its `TextureHandle` scrolls out. + Add an image atlas only if a measured screen shows enough small images + to matter, which a transcript rarely does. +4. **Drop the three features and the two `max_binding_array_*` limits from + `src/default/render.rs`**, and the `UiLimits` counts with them. +5. **Sampling is `NonFiltering` today** (`render/mod.rs:290,299`), so a + downscaled attachment will alias. Either request a filtering sampler + for the image slot or downscale on the CPU before upload; decide when + the image widget is touched, not as part of this. + +What this costs against the file's original recommendation: `Textures` +needs to know an image from a page (two kinds of handle, or a kind on +`TextureHandle`), and `Primitives` gets a second instance list per layer. +What it saves: the sort, the size threshold, the eviction policy, and any +per-page bind group switch. From d194d734393220689f3e1a59a6db080cd9960e9f Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 21:59:38 -0400 Subject: [PATCH 20/77] LAYOUT.md: Iris's single-draw preference, recorded before design Co-Authored-By: Claude Fable 5.1 --- LAYOUT.md | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 LAYOUT.md diff --git a/LAYOUT.md b/LAYOUT.md new file mode 100644 index 0000000..86a4e8b --- /dev/null +++ b/LAYOUT.md @@ -0,0 +1,96 @@ +# iris: one `draw` that reports a size + +Preference stated by Iris, 2026-09-04, on the `rustify` branch. Recorded before +any design or code so that it survives a cleared session. **Status: a +requirement with a design to be written below it. Nothing implemented.** + +## What Iris asked for + +> I don't like that widgets need both a draw and size functions. I'd much +> rather them have a single draw that reports a size, and if it needs to be +> moved then that can be done after the fact efficiently, or resized just +> done after as well. This should be done efficiently like everything else +> tries to do right now. + +She added, a few minutes later: "single draw is not a requirement. It +just seems more efficient from what I've heard. Feel free to override any +decision I've made if you can find a genuinely better & still clean +alternative." So the single-draw model is the default to design against, +and the design below may reject it, but only with a written comparison +showing the alternative does less work per frame and is no harder to use. + +Standing constraints from RUST.md still apply: no DSL, plain Rust, do as +little processing as possible per frame, but the model must cover every +layout need a real app has (the transcript's virtualised list, wrapped +text whose height depends on width, rows and columns that size to their +children, overlays, masks). + +## What exists today + +`Widget` (`iris/core/src/widget/mod.rs`) has three methods: `draw(&mut +self, &mut Painter)`, `desired_width(&mut self, &mut SizeCtx) -> Len` and +`desired_height`. A parent asks `SizeCtx::width/height` for a child, which +is memoised per widget id and axis in `Cache.size` keyed on the outer +size, then places the child with `Painter::widget_within(region)`. So a +child is visited twice (sized, then drawn), every widget implements sizing +twice (one per axis), and a widget whose size depends on what it draws +(wrapped text, a laid-out paragraph) does the layout in the size pass and +again in the draw pass unless it caches by hand. + +Primitives are already positioned by `UiRegion` values whose scalars have +a `rel` and an `abs` part, resolved against the window in the vertex +shader (`core/src/render/shader.wgsl`), and `Primitives::region_mut` +exists to rewrite one instance's region in place. That is the mechanism a +"move after the fact" can build on. + +## What the design must answer + +1. **Parent-before-child ordering.** A row has to know each child's width + to place the next one, but under "one draw" the child's size only + exists after it has drawn. The answer is meant to be: the child draws + at a provisional origin, reports its size, and the parent *moves* it. + The move must be O(1) per moved subtree, not O(primitives in the + subtree). One way: every instance carries an index into a small + per-widget offset buffer, so moving a widget writes one entry and the + vertex shader adds it. Other ways may be better; the design should say + what was considered. +2. **Move vs resize are different costs and must be kept apart.** A move + never re-runs `draw`. A resize re-runs `draw` for exactly the widgets + whose size input changed, and a widget whose output does not depend on + its size (an icon, a fixed rect) must be able to say so and be skipped. +3. **Size-dependent content.** Wrapped text is the hard case: its height + is a function of its width. A single `draw` receives the available + size (what `SizeCtx.outer` is today) and reports what it used, so the + two-pass "measure then draw" collapses into one for the common case. + The design must say what happens when a parent wants the child's + height *before* deciding the width it will offer (rare; say whether it + is supported, or is done by drawing twice as an explicit, opt-in cost). +4. **Caching.** Today's `Cache.size` memoises by (id, axis, outer). The + replacement should memoise the whole draw result by (id, available + size) so that an unchanged subtree costs nothing on the next frame, + which is what makes a virtualised list cheap. +5. **Everything currently written against `desired_width`/`desired_height` + moves over in one change**, per the code rules: two names for one + concept is not an intermediate state to leave behind. The widgets are + in `iris/src/widget/` (`ptr`, `mask`, `image`, `rect`, `trait_fns`, and + whatever else is there when the change is made). + +## Order relative to the texture work + +TEXTURES.md's redesign touches the render core (shader, `GpuTextures`, +`Primitives`, `Painter`'s texture calls). This change touches the widget +trait, `SizeCtx`, `Cache`, `Painter`'s widget calls, and any offset +mechanism the vertex shader needs. They overlap in `Painter` and the +shader, so they are done **in sequence, textures first**, and the layout +design here is written (not implemented) while the texture work is in +progress, then implemented on top of it. + +## Design (to be written by the agent that takes this) + +Not yet written. When it is, it replaces this heading and records: the +new `Widget` trait, how a move is expressed and what it costs, how a +resize is scoped, how the result is cached and invalidated, what was +rejected and why, and the pass conditions the implementation is checked +against (the existing examples under `iris/examples` still render the +same, and the per-frame work for an unchanged tree is measured, not +assumed). From 1c937e2f488b7a0c04a1c2c7561a276759d4dab0 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 22:14:51 -0400 Subject: [PATCH 21/77] LAYOUT.md: single-draw design with an O(1) move chain; IRIS.md for notable API changes Co-Authored-By: Claude Fable 5.1 --- IRIS.md | 11 + LAYOUT.md | 622 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 623 insertions(+), 10 deletions(-) create mode 100644 IRIS.md diff --git a/IRIS.md b/IRIS.md new file mode 100644 index 0000000..7630e6c --- /dev/null +++ b/IRIS.md @@ -0,0 +1,11 @@ +# iris: notable public API changes + +For Iris to read on her own time. Each entry is a change to iris's public +surface that a widget author or app author would notice: a trait method +added, removed or re-shaped; a type that callers construct differently; a +capability that moved. Small and trivial changes do not go here. + +An entry gives the date, what changed, why, and a short before/after where +it helps judge the change without the session that made it. Newest first. + +_No entries yet._ diff --git a/LAYOUT.md b/LAYOUT.md index 86a4e8b..0f61a79 100644 --- a/LAYOUT.md +++ b/LAYOUT.md @@ -1,8 +1,13 @@ # iris: one `draw` that reports a size Preference stated by Iris, 2026-09-04, on the `rustify` branch. Recorded before -any design or code so that it survives a cleared session. **Status: a -requirement with a design to be written below it. Nothing implemented.** +any design or code so that it survives a cleared session. **Status: design +written 2026-09-04, on top of TEXTURES.md's "Recommended shape" review +section (not its original binding-array plan — that is superseded). Nothing +implemented yet.** Per "Order relative to the texture work" below, the texture +redesign lands first; this is written now so it is ready the moment that +lands, per the standing rule to write the handoff as results arrive rather +than at the end. ## What Iris asked for @@ -85,12 +90,609 @@ shader, so they are done **in sequence, textures first**, and the layout design here is written (not implemented) while the texture work is in progress, then implemented on top of it. -## Design (to be written by the agent that takes this) +## Design -Not yet written. When it is, it replaces this heading and records: the -new `Widget` trait, how a move is expressed and what it costs, how a -resize is scoped, how the result is cached and invalidated, what was -rejected and why, and the pass conditions the implementation is checked -against (the existing examples under `iris/examples` still render the -same, and the per-frame work for an unchanged tree is measured, not -assumed). +### 1. The new `Widget` trait + +```rust +pub trait Widget: Any { + /// Draw within `painter.region()` (the space the parent offered) and + /// report how much of it was actually used, per axis. + fn draw(&mut self, painter: &mut Painter) -> Size; + + /// True if `draw`'s output (both the primitives it writes and the + /// `Size` it returns) is the same for any `painter.region()` of the + /// same *content* -- an icon, a fixed-size rect, an already-decoded + /// image at its natural size. Default `false` (redraw on any change to + /// the offered region) because assuming independence wrongly produces + /// a stale draw; a widget must opt in. + fn is_size_independent(&self) -> bool { + false + } +} +``` + +No `available` parameter: `Painter` already carries the region the parent +handed down (`Painter::region()`, `core/src/ui/painter.rs:137`) and already +exposes the pixel-resolved form (`px_size()`, `:156`) and the output surface +size (`output_size()`, `:152`). Passing it again would be the same value +under a second name. `desired_width`/`desired_height` (`core/src/widget/mod.rs:20-21`) +and `WidgetAxisFns::desired_len` (`:24-35`) are deleted outright — not +deprecated, not kept as a fallback — because a widget that implements both +`draw` and `desired_*` for the same thing is exactly the "two names for one +concept" the code rules call out, and it is what today's `Span::desired_ortho` +(`iris/src/widget/position/span.rs:98-152`) already complains about in its +own comment: "this literally copies draw so that the lengths are correctly +set in the context, which makes this slow and not cool." Folding sizing into +`draw` deletes that duplicate simulation, not just moves it. + +**No single-draw alternative was found that does less work per frame.** The +two-method trait was checked against three properties a real screen needs — +a row placing children in sequence, a widget centering on its own content, +and wrapped text — and in every one, `draw` already has to visit the child +to get a size that is *this specific one's* answer, which today's +`desired_width`/`desired_height` re-derive by re-running (a shrunk copy of) +the same layout the draw pass will do again. So the two-method trait is not +"measure once, draw once" in the general case; it is "measure once per axis, +then draw once," i.e. up to three visits per widget per frame, against one +under the design here. The single-draw model is therefore adopted as +proposed, not merely accepted as a preference. + +### 2. Move: O(1) per moved subtree, via a per-widget offset chain + +**What exists today, and why it is not O(1).** `UiRenderState::mov` +(`core/src/ui/render_state.rs:156-168`) fires when a widget's region keeps +its *size* but changes *position* (`draw_inner`, `:85-100`: +`active.region.size() == region.size()` after excluding the exact-match +case). It rewrites every primitive's `region` field via +`Primitives::region_mut` (`core/src/render/primitive.rs:176-179`) for the +widget's own primitives, then recurses into every child — O(primitives in +the subtree). Both call sites that trigger it today, `Scroll::draw` +(`iris/src/widget/position/scroll.rs:29-31`) and `Offset::draw` +(`iris/src/widget/position/offset.rs:9-11`), are "translate this subtree by +an abs pixel amount, `rel` framing unchanged" — a transcript scroll +re-touches every glyph in every visible row, every frame of the drag, and +I3's target is 800 rows on screen. + +**Recommendation: a per-widget offset slot forming a parent-linked chain, +resolved in the vertex shader.** + +- `UiData` (`core/src/ui/mod.rs:14-20`) gains + `pub move_offsets: TrackedArena`, the same arena shape + already used for `masks: TrackedArena` on the line above it. +- `render/data.rs` gains `pub struct MoveOffset { pub delta: [f32; 2], pub + parent: u32 }` (`Pod`/`Zeroable`, `parent = u32::MAX` = "no ancestor, + add nothing more"). A pure abs-pixel translation, not a general + `UiRegion` remap — sufficient for every existing call site (above). +- `PrimitiveInstance` (`render/data.rs:11-18`) gains `pub move_idx: u32`, + a vertex attribute at `@location(7)` beside `mask_idx` at `6` — the same + kind of per-instance handle. +- `ActiveData` (`core/src/ui/active.rs`) gains `pub move_slot: MoveIdx`, + assigned **when the widget is first drawn** (`draw_inner`, beside + `active.insert`), with `parent` = the drawing widget's parent's slot. + `Painter` threads a `move_slot` field down exactly as it already threads + `mask` and `layer` (`painter.rs:9-20`), so a freshly-drawn descendant is + correct from its first frame — nothing is ever retrofitted onto an + already-active primitive. An unmoved widget's slot just stays `[0, 0]`. +- `Painter::primitive_at` (`painter.rs:23-38`) writes `move_idx: + self.move_slot`, matching how it already writes `mask_idx: self.mask`. +- `mov(id, delta)` becomes: look up `id`'s slot, write + `move_offsets[slot].delta += delta`. One write — no primitive touched, no + recursion, since descendants already reference this slot transitively. +- `shader.wgsl`'s vertex stage, after computing `top_left`/`bot_right` in + pixels (after `:106`, before the clip-space divide at `:113`), walks + `move_idx → move_offsets[i].parent` for a bounded number of steps (a + small constant, e.g. 16, with a CPU-side debug assertion that no chain + exceeds it), summing `delta` into both corners. Cost is O(chain depth), + paid every frame regardless of whether anything moved — negligible next + to the per-fragment texture sampling TEXTURES.md already measures this + GPU as not bound by. + +**Why the chain, not the flatter thing first proposed.** Iris's own +phrasing — "every instance carries an index into a small per-widget offset +buffer" — describes a flat table: one slot per subtree *declared* movable, +no parent link. It breaks the moment two such subtrees nest — a row inside +a scrolling list, itself later given its own animated offset (a +swipe-to-delete mid-scroll) — because the row's primitives would have to +pick one slot and lose the other's contribution. The chain costs one extra +field and a bounded shader loop in exchange for no such gap, and since +every `ActiveData` gets a slot unconditionally rather than lazily, it costs +no more at the common depth of one than the flat version would. + +**Against `region_mut` as the steady-state mechanism**: rejected for being +O(primitives in the subtree) — the cost this section removes — but kept +for a resize that changes a region's `rel` component (a genuine reflow, +§3) and for a size-independent widget's resize (§3), where the content's +shape doesn't change and one field write already suffices. + +### 2b. Two more readers of "where is this widget," and masks + +Moving the offset into the vertex shader means `ActiveData.region` is no +longer the on-screen truth once a widget has been moved — it is where the +widget was *drawn*, before any `move_offsets` delta. Two things read it as +if it still were, and both must move to a resolved query or they silently +answer with the pre-move position: a click landing on a scrolled row would +be routed to whatever used to be there, with nothing on screen to say so — +exactly the "wrong answer that looks like a right one" case the code rules +single out. + +**Hit-testing.** `SensorUi::run_sensors` (`src/default/sense.rs:154-200`) +does the actual pointer routing, and line 170 is the read in question: +`let shape = self.active.get(id).unwrap().region;` (`self: &UiRenderState`), +immediately turned into pixels and tested against the cursor at `:171-172`. +Under this design that region must be resolved through the same chain the +GPU walks before it means anything. Add to `UiRenderState`: + +```rust +/// `active[id].region`, corrected by every `move_offsets` delta between +/// `id` and the root — the CPU-side twin of the vertex shader's chain +/// walk, over the same arena, so the two cannot disagree about where a +/// widget is. O(chain depth), not O(primitives): a plain Rust loop over +/// `move_offsets`, bounded by the same constant the shader loop uses +/// (name it once, e.g. `render::MOVE_CHAIN_LIMIT`, and reference it from +/// the WGSL loop bound in a comment, since WGSL cannot `include!` a Rust +/// const across the language boundary). +pub fn resolved_region(&self, id: WidgetId) -> UiRegion; +``` + +`window_region` (`core/src/ui/render_state.rs:264-267`), the public +coordinate query already used outside hit-testing +(`src/default/attr.rs:15,17,70`, e.g. positioning one widget relative to +another's on-screen box), is reimplemented to call `resolved_region(id)` +before `.to_px(...)` instead of reading `.region` directly — one change +covers both call sites listed there. `sense.rs:170` changes to +`let shape = self.resolved_region(*id);`. Both are required the moment §2 +lands, not an optional follow-up: an unmoved widget's chain is empty and +`resolved_region` costs one arena read to find that out, so there is no +version of this design where skipping the fix is a legitimate +optimization — it is a correctness gap, not a performance one. + +**Masks.** `Painter::set_mask` (`core/src/ui/painter.rs:49-52`) bakes the +painter's *current* region into a `Mask` pushed onto +`masks: TrackedArena` (`core/src/ui/mod.rs:19`), and the +fragment shader clips every primitive against `masks[in.mask_idx]`'s raw +`rel`/`abs` fields, unaffected by any move (`shader.wgsl:147-157`). If the +widget that called `set_mask` — `Masked::draw`, +`iris/src/widget/mask.rs:7-11`, `painter.set_mask(painter.region()); ...` — +is itself later moved, its clip rectangle stays where it was drawn while +its content moves out from under it: a visibly wrong clip, immediately on +screen, not a latency question. + +Fix: `Mask` (`core/src/render/data.rs:46-49`) gains `pub move_idx: u32`, +written from `Painter::set_mask` as `self.move_slot` — the identical slot +the mask-owning widget's own primitives already get (§2), not a second +mechanism. Resolution happens in the **fragment** shader, not the CPU, and +not the vertex shader either: `shader.wgsl`'s mask check (`:147-157`) +currently computes the mask's `top_left`/`bot_right` inline from +`masks[in.mask_idx]`; that computation is extended to walk the same +move-offset chain §2 added, via one shared function — + +```wgsl +fn resolve_move(idx: u32) -> vec2 { /* the bounded parent walk, used by both stages */ } +``` + +— called from `vs_main` for a primitive's own corners and from `fs_main` +for its mask's corners, so the walk is written once and the two stages +cannot drift apart (the sibling-rule from the code rules: one loop, not a +hand-copied second one in the other shader stage). + +**Why the fragment shader, not a CPU-side mask rewrite at move time.** A +primitive's mask is frequently owned by a *different* widget than the +primitive itself — often several levels up a subtree, with its own, +independent move slot — so a primitive's resolved offset and its mask's +resolved offset are two different chain sums, both needed, and only the +fragment shader has both `in.move_idx` (this fragment's own chain) and +`in.mask_idx` (indirecting to a second, possibly unrelated chain) already +in hand per-fragment. Resolving mask regions on the CPU at move time would +mean, for every `mov()` call, walking forward to every mask instance the +moved widget's slot could affect and rewriting its raw region — exactly +the O(subtree) cost §2 exists to remove, just moved from primitives to +masks. The fragment shader already re-reads `masks[in.mask_idx]` every +frame (`:148`); one more arena read to resolve its chain costs nothing +extra in kind. + +**The scroll-container case, checked rather than assumed.** A masked, +scrollable region is built as a `Masked` wrapping a `Scroll` +(`iris/src/widget/position/scroll.rs`, `iris/src/widget/mask.rs`) — the +viewport border is drawn (and `set_mask` called) by `Masked`, which is +never itself the target of `mov()`; only `Scroll`'s inner content is, +every frame the user drags. Because each widget's move slot is its own +(§2: assigned per `ActiveData`, not shared), `Masked`'s mask references +its own, stationary slot, while the scrolled content underneath references +a separate, deeper slot whose `parent` chain passes through — but does not +write to — the viewport's slot. Moving the content therefore never touches +the mask's resolved position, and the mask staying still while its content +slides past it is what this design already produces with no special case, +not an extra rule that had to be added for it. + +### 3. Resize scope + +A resize is "the region a widget's parent offers it changes such that the +widget's draw might produce different output" — as opposed to a move, which +by construction cannot (§2 is scoped to pure translation). Two independent +narrowings apply, and both are real, measured properties of the code as it +stands rather than new machinery: + +**(a) A window resize does not, by itself, require touching most widgets.** +`shader.wgsl:105-106` recomputes every primitive's pixel position from +`window.dim` and the primitive's stored `rel`/`abs` pair *every frame, +already, on the GPU*. A widget laid out purely in `rel`/`abs` terms (no +call to `px_size()`, `output_size()`, or anything else that reads a +concrete pixel count) is therefore already correct after a resize with zero +CPU work — the shader did it. `UiRenderState::needs_redraw_all` +(`render_state.rs:229-231`) currently ignores this and redraws the entire +tree on every `resized`, which was the safe default while sizing and +drawing were two passes; it should be narrowed to only the widgets that +*do* read a concrete pixel value. Track this the same way `needs_redraw` +already tracks per-widget dirtiness (`Widgets::needs_redraw`, +`core/src/widget/widgets.rs:9`): a widget's `draw` call marks itself +pixel-dependent by calling through `Painter` methods that read +`output_size`/`px_size` (both already funnel through `Painter`, so the +marking is one line at each), and `resize()` (`render_state.rs:32-35`) +walks only that set instead of unconditionally setting `resized = true` +for a full `redraw_all`. This turns "every resize redraws everything" into +"every resize redraws what depends on pixels" — a real behavior change +beyond what was asked, so verify it against the I0b `pre_present_notify` +resize regression (that fix depended on `redraw_all`'s completeness) +before narrowing this. + +**(b) A widget's `available` (its parent's offered region) can change +without the widget's *content* changing — this is what +`is_size_independent` (§1) answers.** When a container's own layout shifts +(a sibling grew or shrank, changing this widget's offered box), a widget +that returns `true` from `is_size_independent` is not redrawn: its +primitives are unaffected by size, only by placement, so the parent +either (i) issues a move (§2) if only position changed, or (ii) rewrites +the primitive's `region` fields directly via `region_mut` if the box +changed shape too (still O(primitives owned directly by this widget, not +its subtree, since a size-independent widget by definition has no +size-dependent descendants worth distinguishing — in practice this is +always a leaf: `Rect`, `Image`, a fixed glyph). A widget that returns +`false` (the default) is redrawn in full whenever `available` changes, +which is correct always, just not free. + +**Ancestor propagation** (a resized child changing its own reported size, +requiring its parent to re-lay-out) is unchanged in spirit from today's +`redraw` (`render_state.rs:270-305`), which already walks up exactly the +ancestors whose cached size differs from the new one and stops as soon as +a size is unchanged (`:274-286`). That loop moves from consulting +`Cache.size` to consulting `ActiveData.size` (§5) but keeps its shape. + +### 4. Wrapped text, and "needs child height before choosing width" + +**Wrapped text is not a special case any more; it already reads as one +draw.** `TextView::render` (`iris/src/widget/text/mod.rs:57-76`) already +does exactly what single-draw asks for: it reads `ctx.px_size().x` as the +wrap width, shapes once, and memoizes the shaped layout keyed on that width +plus a changed-flag on the buffer and attrs (`:63-69`) — a second call with +the same width is a hash-map-style cache hit, not a re-shape. Under the new +trait this collapses `Text::draw`/`desired_width`/`desired_height` +(`text/mod.rs:133-147`, three functions) into one `Text::draw` that calls +`self.view.draw(painter)` once, which internally still calls `render` +once, hits its own cache, and returns the size it already computed. No +new caching is needed here; the two now-redundant call sites +(`desired_width`/`desired_height` each separately calling `render`) simply +disappear, which is a second `render` avoided per frame per text widget +that is being measured by a parent. + +**"Parent wants the child's height before deciding the width it will +offer"** — the genuinely circular case named in the brief, e.g. a column +that sizes its own width to its widest child, where that child is wrapped +text whose height (which the column's *own* height depends on) depends on +the width the column has not yet decided. This is not solvable in one pass +for the same reason it is not solvable in CSS shrink-to-fit with wrapped +content: the two axes' answers are mutually dependent. `Span::desired_ortho` +(`span.rs:98-136`) already hits exactly this today and already resolves it +by an explicit second, throwaway pass (its own comment: "this literally +copies draw ... which makes this slow and not cool"). The design keeps that +resolution, made explicit rather than accidental: `Painter` gets + +```rust +/// Draw `child` at a provisional region to learn its size under one +/// axis's worth of assumption, discard everything it wrote, then draw it +/// again at the region that assumption produced. For the rare parent that +/// cannot pick an offered size without already knowing the answer. +/// Twice the cost of one `draw`; every other case in this file avoids it. +pub fn draw_twice(&mut self, child: &StrongWidget, first: UiRegion, second: impl FnOnce(Size) -> UiRegion) -> Size; +``` + +implemented as: draw at `first`, record `Size`, remove the widget and its +subtree the same way a resize-triggered redraw already does (`draw_inner`'s +"if not \[same region\], maintain resize and track old children," `:97-100`, +which already frees the old primitives before redrawing) — reusing that +path rather than adding a second one — draw again at `second(size)`, return +the final `Size`. It is opt-in and named for its cost, so a widget only +pays it if it is the one that needs it; `Span`'s cross-axis case is the one +call site converted to it, replacing the hand-rolled duplicate loop. + +### 5. Caching and invalidation + +`Cache.size` (`core/src/ui/cache.rs`) is **deleted, not replaced with an +equivalent** — the thing it memoized (a `desired_width`/`desired_height` +answer, independent of drawing) no longer exists as a separate query, so +there is nothing left to cache at that layer. What already provides "an +unchanged subtree costs nothing" is the check `draw_inner` performs before +touching a widget at all (`render_state.rs:85-90`): if the widget is active, +its region is unchanged, and it is not marked dirty, `draw_inner` returns +immediately — no `Painter` constructed, no primitive touched, no shader +work beyond what the GPU already redraws from the unchanged instance +buffer. That check is kept exactly as it is; it is the caching mechanism, +and it already operates at (id, region) granularity, which subsumes "(id, +available size)" once size *is* what a region change means. + +What is added: `ActiveData` gains `pub size: Size` — the value `draw` +returned, stored the moment it is (`draw_inner`, alongside building the +`ActiveData` struct at `:134-143`). This is what a parent placing this +widget for a second frame without redrawing it (because nothing changed) +reads instead of recomputing — it replaces `Cache.size`'s role of "answer a +size question without a full draw" with "read the size of the last actual +draw," which is always available because `draw_inner`'s skip path is only +reachable once the widget has been drawn at least once. `Cache::remove`/ +`Cache::clear` (`cache.rs:9-17`) are deleted with the type; `ActiveData` +already has an equivalent lifecycle (removed in `remove`/`remove_rec`, +`render_state.rs:171-198`, freed with the widget). + +### 6. Before / after + +**A leaf, `iris/src/widget/rect.rs`** — the size-independent case: + +```rust +// before +impl Widget for Rect { + fn draw(&mut self, painter: &mut Painter) { + painter.primitive(RectPrimitive { color: self.color, radius: self.radius, + thickness: self.thickness, inner_radius: self.inner_radius }); + } + fn desired_width(&mut self, _: &mut SizeCtx) -> Len { Len::rest(1) } + fn desired_height(&mut self, _: &mut SizeCtx) -> Len { Len::rest(1) } +} +``` + +```rust +// after +impl Widget for Rect { + fn draw(&mut self, painter: &mut Painter) -> Size { + painter.primitive(RectPrimitive { color: self.color, radius: self.radius, + thickness: self.thickness, inner_radius: self.inner_radius }); + Size::REST // fills whatever it was given -- used == available + } + fn is_size_independent(&self) -> bool { true } // content never depends on region size +} +``` + +**A container that needs the child's size before placing it, +`iris/src/widget/position/align.rs`**: + +```rust +// before +impl Widget for Aligned { + fn draw(&mut self, painter: &mut Painter) { + let region = match self.align.tuple() { + (Some(x), Some(y)) => painter.size(&self.inner).to_uivec2().align(RegionAlign { x, y }), + (Some(x), None) => { let x = painter.size_ctx().width(&self.inner).apply_rest().align(x); + UiRegion::new(x, UiSpan::FULL) } + (None, Some(y)) => { let y = painter.size_ctx().height(&self.inner).apply_rest().align(y); + UiRegion::new(UiSpan::FULL, y) } + (None, None) => UiRegion::FULL, + }; + painter.widget_within(&self.inner, region); + } + fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { ctx.width(&self.inner) } + fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { ctx.height(&self.inner) } +} +``` + +```rust +// after +impl Widget for Aligned { + fn draw(&mut self, painter: &mut Painter) -> Size { + let full = painter.region(); + // Draw once at the full region to learn the child's real size -- + // this placement is provisional and corrected below without a + // second draw. + let used = painter.widget_within(&self.inner, full); + let region = match self.align.tuple() { + (Some(x), Some(y)) => used.to_uivec2().align(RegionAlign { x, y }).within(&full), + (Some(x), None) => used.x.apply_rest().align(x).within(&full), + (None, Some(y)) => used.y.apply_rest().align(y).within(&full), + (None, None) => full, + }; + painter.reposition(&self.inner, region); // O(1): one offset write, no second draw + used + } +} +``` + +`Painter::widget_within`/`widget`/`widget_at` (`painter.rs:55-76`) change +return type from `()` to `Size`, carrying the child's `draw` result back — +the only signature change needed to let a parent see what its child used. +`Painter::reposition` is new, computing the delta between where a child +was actually drawn and where it belongs and calling the O(1) `mov` from +§2. `SizeCtx` and `Painter::size_ctx`/`size`/`len_axis` (`painter.rs:141-150, +180-182`) are deleted — nothing calls `desired_len` any more, so there is +nothing left for `SizeCtx` to answer; `draw_text`/`label`/`px_size`/ +`output_size` already exist redundantly on both `SizeCtx` and `Painter` +today (compare `size.rs:71-90` against `painter.rs:152-174`) and this +deletes the `SizeCtx` copies, keeping the `Painter` ones. + +### 7. Migration — every file and widget that changes + +One change, in dependency order (rename-and-move-together, per the code +rules — no intermediate state with both trait shapes): + +- `core/src/widget/mod.rs` — the `Widget` trait (§1), delete + `WidgetAxisFns`, update `impl Widget for ()`. +- `core/src/ui/size.rs` — delete `SizeCtx` (the type and all its methods). +- `core/src/ui/cache.rs` — delete `Cache` (§5). +- `core/src/ui/painter.rs` — `widget`/`widget_within`/`widget_at` return + `Size`; add `reposition`, `draw_twice`; delete `size_ctx`, `size`, + `len_axis`; `primitive_at` writes `move_idx`. +- `core/src/ui/render_state.rs` — `draw_inner` captures and stores + `ActiveData.size`; `mov` becomes the O(1) offset write (§2); resize + narrowing (§3a); `redraw`'s per-axis loop reads `ActiveData.size` + instead of `Cache.size`. +- `core/src/ui/active.rs` — `ActiveData` gains `size: Size`, + `move_slot: MoveIdx`. +- `core/src/ui/mod.rs` — `UiData` gains `move_offsets`. +- `core/src/render/data.rs` — `PrimitiveInstance` gains `move_idx`; + new `MoveOffset` struct. +- `core/src/render/primitive.rs` — thread `move_idx` through `PrimitiveInst` + and `Primitives::write`, matching `mask_idx`. +- `core/src/render/mod.rs` — bind the new `move_offsets` storage buffer + (group 2, beside `masks`) and its update path. +- `core/src/render/shader.wgsl` — `InstanceInput` gains `move_idx`; + `MoveOffset`/`UiScalar`-shaped storage binding; a shared `resolve_move` + function (§2b) called from both `vs_main` (a primitive's own corners) + and `fs_main` (its mask's corners, once `Mask` carries `move_idx`). +- `core/src/ui/render_state.rs` — additionally, `resolved_region` (§2b) + and `window_region` (`:264-267`) reimplemented on top of it. +- `src/default/sense.rs` — `run_sensors`'s hit-test read (`:170`) switches + from `self.active.get(id).unwrap().region` to `self.resolved_region(*id)` + (§2b) — the pointer-routing fix this design requires, not an optional + follow-up. +- `core/src/render/data.rs` — additionally, `Mask` (`:46-49`) gains + `move_idx: u32` (§2b). +- `core/src/ui/painter.rs` — additionally, `set_mask` (`:49-52`) writes + `move_idx: self.move_slot` into the `Mask` it pushes (§2b). +- Every widget with a two-method `impl Widget`, collapsed to one `draw` + (§1, §6), `is_size_independent` added where true: `core/src/widget/mod.rs` + (`impl Widget for ()`), `iris/src/widget/rect.rs` (`Rect`, → true), + `iris/src/widget/image.rs` (`Image`, → true — a decoded image's primitive + never depends on the region it is offered, same as `Rect`), + `iris/src/widget/mask.rs` (`Masked`), `iris/src/widget/ptr.rs` + (`WidgetPtr`), `iris/src/widget/text/mod.rs` (`Text`, §4), + `iris/src/widget/text/edit.rs` (`TextEdit`), + `iris/src/widget/position/scroll.rs` (`Scroll`, keeps its `mov`-shaped + offset, now O(1) automatically via §2), `iris/src/widget/position/align.rs` + (`Aligned`, §6), `iris/src/widget/position/max_size.rs` (`MaxSize`), + `iris/src/widget/position/layer.rs` (`LayerOffset`), + `iris/src/widget/position/pad.rs` (`Pad`), + `iris/src/widget/position/stack.rs` (`Stack`), + `iris/src/widget/position/offset.rs` (`Offset`), + `iris/src/widget/position/span.rs` (`Span`, §4's `draw_twice` for the + cross-axis case, deleting `desired_ortho`'s duplicate loop), + `iris/src/widget/position/sized.rs` (`Sized`). + This list was produced by `grep -rn "impl Widget for\|fn desired_width\|fn desired_height"` + across `core/` and `src/`; re-run it before starting, since it is the + authoritative check that nothing was missed, not this paragraph. +- `iris/examples/{minimal.rs,task.rs,view.rs,tabs/main.rs}` — no direct + `impl Widget` found in any example (verified by the same grep); they use + the builder DSL in `core/src/widget/trait_fns.rs` and should need no + source change, which is itself part of the pass condition below. + +### 8. Pass conditions + +1. **Every example under `iris/examples` renders identically.** Run + `iris/run-headless.sh EXAMPLE --shot PNG` for each of `minimal`, `task`, + `view`, `tabs` before and after, and diff the PNGs pixel-for-pixel — not + "looks right," since a subtle wrap or alignment regression is exactly + what a diff catches and a glance does not. +2. **Unchanged-frame cost, measured, not assumed.** Add a counter beside + the existing `debug_layers`/`active_widgets` instrumentation + (`render_state.rs:241-262`) for (a) `Widget::draw` invocations and (b) + `Primitives::write`/`region_mut` calls, both per `update()` call. Drive + one example (`tabs`, since it already has multiple widgets and an + interactive element) through one frame with nothing changed and report + both counts — the pass condition is **0 draws and 0 primitive rewrites** + for a frame in which nothing was marked dirty, resized, or moved. +3. **Single-moved-child cost, measured.** Same counters, one frame in + which exactly one widget is moved (not resized) with N primitives in its + subtree — the pass condition is **1 write to `move_offsets`, 0 calls to + `Widget::draw`, 0 calls to `region_mut`**, independent of N. Construct + the case with a `tabs`-style example holding a deliberately large text + block (hundreds of glyphs) inside a `Scroll`, so N is large enough that + an O(N) regression would show up as a non-trivial write count rather + than being lost in noise. +4. **Hit-testing follows the move, not just the render.** In the same + scrolled-`tabs` construction as condition 3, scroll the content, then + send a synthetic cursor position over a widget that moved and assert + `run_sensors` (`src/default/sense.rs:154-200`) routes to that widget's + id, not to whatever is now at its pre-scroll coordinates or to nothing. + This is a correctness check, not a timing one — §2b's fix is required + before §2 can ship at all, and this is what would fail silently + (nothing on screen indicates a missed or misrouted hit) if it were + skipped. +5. **A mask moves with its subtree.** Render a `Masked`-wrapped `Scroll` + both before and after scrolling it (`iris/run-headless.sh` against a + small purpose-built example, or an addition to `tabs`), and diff the + two frames: the clipped edge of the content must have moved with the + scroll while the viewport's own border (drawn by `Masked`, not moved) + stays put — the specific case worked through in §2b. A mask rectangle + that stayed at its pre-scroll position while its content slid past it + is the regression this checks for, and it is visible in a single + screenshot, not just in a counter. +6. **`cargo test --workspace`, `cargo clippy --all-targets`, `cargo fmt`** + stay clean at the defaults (iris has no tests today per I0b, so this is + presently only clippy/fmt; add the first real widget-layer tests here if + the move-offset chain or `draw_twice` are non-trivial enough to want + one, per "match the codebase's testing posture" — judge that once the + code exists rather than pre-committing to a number of tests here). + +### 9. Rejected, and why + +- **A flat (non-chained) per-subtree offset table**, Iris's literal + phrasing — rejected in §2 for breaking under nested independent moves + (a swiped row inside a scrolling list). Costs nothing extra to avoid: the + chain is the same mechanism with one more field. +- **Keeping `region_mut` recursion as the only move mechanism** — rejected + as the steady-state path (O(primitives in subtree), exactly what a + transcript scroll must not pay every frame) but kept for resize-shaped + changes (§3) where the content's own region field, not an ancestor + chain, is what has to change. +- **A second, size-only trait method kept alongside `draw`** (e.g. + `fn size_hint(&self) -> Option` as a fast path some widgets could + implement to skip a draw when a cheap answer exists) — considered and + rejected: it reintroduces exactly the "two names for one concept" split + this change removes, for a saving `is_size_independent` (§1, §3b) + already covers for the cases where it would actually help (fixed-size + leaves). A widget whose size is cheap to compute but whose *drawing* is + not (unlikely in this codebase's widget set, but conceivable) is better + served by that widget caching its own draw output internally — exactly + the pattern `TextView::render` already uses (§4) — than by a second + trait method every implementor has to reason about. +- **Passing `available` as an explicit parameter to `draw`** (mirroring + Masonry's `layout(&mut self, ctx, bc: &BoxConstraints) -> Size`, the + yardstick per AGENTS.md) — rejected as redundant with `Painter::region()`, + which already carries the same information into every widget that needs + it; adding a parameter would just be a second route to a value already + reachable, and would invite the two drifting apart. +- **Eagerly propagating a moved widget's delta into every descendant's own + offset value** (rather than chaining and resolving in the shader) — + rejected as O(descendant widgets), which is smaller than O(primitives) + but still not O(1), and the shader-side chain costs nothing extra to get + the better bound. + +## For IRIS.md + +When this lands, copy this entry into `IRIS.md` (newest first): + +> **2026-09-04 — `Widget::draw` reports the size it used; `desired_width`/ +> `desired_height` are gone.** A widget used to implement three methods +> (`draw`, `desired_width`, `desired_height`); it now implements one, +> `fn draw(&mut self, painter: &mut Painter) -> Size`, which draws into +> `painter.region()` and returns how much of it was used. Why: the two +> extra methods routinely re-simulated what `draw` was about to do anyway +> (`Span::desired_ortho` copied its own draw loop to get cross-axis sizing +> right) — one visit per widget per frame instead of up to three. A +> container that needs a child's size before placing it (alignment, +> centering) draws the child once at a provisional region, reads the +> returned `Size`, and calls the new `Painter::reposition` to move it into +> its final spot — an O(1) offset write, not a second draw. A widget whose +> drawn output never depends on the size it's given (a fixed-size `Rect`, +> a decoded `Image`) overrides the new `fn is_size_independent(&self) -> +> bool { false }` to `true`, which skips redrawing it when only its +> offered region changes shape. +> +> ```rust +> // before +> fn draw(&mut self, painter: &mut Painter) { /* ... */ } +> fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len { /* ... */ } +> fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len { /* ... */ } +> +> // after +> fn draw(&mut self, painter: &mut Painter) -> Size { /* ... */ } +> ``` +> +> `SizeCtx` and `Cache` are gone with it — see `LAYOUT.md` for the full +> design, the move-offset mechanism this shipped alongside, and the file +> list. From e0a473e0906c18d1d19f1c854828bb1ea6a22782 Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 22:28:54 -0400 Subject: [PATCH 22/77] iris: replace the bindless texture array with an atlas array + per-image bind groups The old pipeline bound every texture ever drawn (glyph atlas pages and standalone images alike) in one binding_array> and asked every device, unconditionally, for VK_EXT_descriptor_indexing -- which a real share of Android GPUs lack and which failed outright on the Android emulator's software Vulkan (see TEXTURES.md's "iris's binding array does not survive real Android hardware"). Implements TEXTURES.md's "Recommended shape": the glyph atlas is now one texture_2d_array (a layer per page, grown by doubling + GPU-side copy_texture_to_texture); a standalone image is its own ordinary Texture and BindGroup, drawn with its own draw() call from a separate per-layer instance list; group 2's layout is {atlas array, one image slot, sampler, masks}. request_device now asks for no features and no binding-array limits at all, and UiLimits is gone. Also fixes (by making moot) the changed=false bug the review found, where a Patch in the same batch could cancel an earlier Push's rebuild signal, and documents the swap_remove draw-order invariant apply_free already relied on. Verified: cargo fmt/build/clippy/test clean in iris/ on the pinned nightly; minimal and tabs render correctly via run-headless.sh; a throwaway example confirmed the standalone-image bind-group path renders; rigs/gpu-probe, updated to the new empty feature/limit set, confirms request_device succeeds on the ai-app-2 emulator's software Vulkan (EMU_GPU=software) -- see TEXTURES.md's "Implemented, 2026-09-04" for the exact command and output. RUST.md's blocking item is resolved. Co-Authored-By: Claude Sonnet --- IRIS.md | 39 ++- RUST.md | 39 ++- TEXTURES.md | 148 ++++++++++ iris/core/src/primitive/layer.rs | 12 + iris/core/src/primitive/texture.rs | 136 +++++++--- iris/core/src/render/atlas.rs | 15 +- iris/core/src/render/mod.rs | 164 ++++++----- iris/core/src/render/primitive.rs | 196 +++++++++++--- iris/core/src/render/shader.wgsl | 39 +-- iris/core/src/render/texture.rs | 419 ++++++++++++++++++++++++----- iris/core/src/render/util/mod.rs | 9 +- iris/core/src/ui/painter.rs | 35 ++- iris/src/default/render.rs | 20 +- rigs/gpu-probe/src/main.rs | 107 +++----- 14 files changed, 1046 insertions(+), 332 deletions(-) diff --git a/IRIS.md b/IRIS.md index 7630e6c..98f5422 100644 --- a/IRIS.md +++ b/IRIS.md @@ -8,4 +8,41 @@ capability that moved. Small and trivial changes do not go here. An entry gives the date, what changed, why, and a short before/after where it helps judge the change without the session that made it. Newest first. -_No entries yet._ +## 2026-09-04: texture pipeline rebuilt off the binding array + +`Textures`/`TextureHandle`, `GlyphPrimitive`, and `UiRenderNode::new` all +changed shape. Why: the old pipeline bound every texture ever drawn in one +`binding_array>` and asked every device, unconditionally, +for `VK_EXT_descriptor_indexing` — a real share of Android GPUs lack it, +and it failed outright on the Android emulator's software Vulkan. See +TEXTURES.md's "Recommended shape" and "Implemented, 2026-09-04". + +- **`UiRenderNode::new` drops its `limits: UiLimits` parameter, and + `UiLimits` is gone.** Before: `UiRenderNode::new(&device, &queue, + &config, UiLimits::default())`. After: `UiRenderNode::new(&device, + &queue, &config)`. Nothing replaces it — there are no more + binding-array limits to size. +- **`src/default/render.rs`'s device request asks for no features and no + binding-array limits.** Before: `required_features: + Features::TEXTURE_BINDING_ARRAY | Features::PARTIALLY_BOUND_BINDING_ARRAY + | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING` + plus two `max_binding_array_*` limits. After: `Features::empty()` (the + `DeviceDescriptor` default) and only `max_buffer_size` set, which was + never about the binding array. +- **`TextureHandle` has no `primitive()` method any more**; a caller + outside `iris` shouldn't have been calling it (it fed the old renderer's + internals), but if something did: use `image_index()` for a standalone + image's bind-group index. There is no equivalent for a page — a page has + no bind group of its own now, see below. +- **`GlyphPrimitive` has no public constructor from a struct literal.** + Before: `GlyphPrimitive { uv_min, uv_max, view_idx, sampler_idx, color, + flags }`. After: `GlyphPrimitive::new(uv_min, uv_max, layer, color, + flags)` — one `layer` (the shared atlas array's layer) instead of a + `view_idx`/`sampler_idx` pair, since a page is now a layer of one array + texture rather than its own bound texture. +- **A widget author drawing images is unaffected**: `Painter::texture`/ + `texture_at`/`texture_within` and `Textures::add` keep their signatures. + What changed underneath is that each standalone image now gets its own + `wgpu::BindGroup` and draw call instead of a slot in the shared array — + invisible from the widget API, visible only in `UiRenderNode`'s internals + and in `iris`'s device requirements. diff --git a/RUST.md b/RUST.md index f36ca11..e175945 100644 --- a/RUST.md +++ b/RUST.md @@ -46,19 +46,25 @@ session spending an afternoon on them again. android-view's `accesskit_android` adapter also has a reproducible abort (a client detaching, not attaching, is the trigger) — see E1 below for both, with the mitigation iris/I4 needs to carry. -- **Blocking, found 2026-09-04, before I2 can be called done**: iris's - texture pipeline asks every device, unconditionally, for - `VK_EXT_descriptor_indexing` ("bindless" binding arrays) — and a - sourced check says a real share of Android hardware does not have it, - not just the emulator's software renderer. See "iris's binding array - does not survive real Android hardware" under the iris track for the - measurement, the sources, and the recommended fix (generalize the - glyph atlas to images, the same way I1 already did for text). Not yet - implemented; a design decision to confirm before iris's render core - changes. -- **Next**: decide on the atlas-based image fix above, then **I2** — - iris on android-view. **E2** (a transcript in Masonry) can go in - parallel in another session. +- **Resolved, 2026-09-04: iris's binding array does not survive real + Android hardware.** iris's texture pipeline used to ask every device, + unconditionally, for `VK_EXT_descriptor_indexing` ("bindless" binding + arrays), which a real share of Android hardware lacks. It has been + rebuilt per TEXTURES.md's "Recommended shape": the glyph atlas is one + `texture_2d_array` (a layer per page), a standalone image is its own + ordinary `Texture`/`BindGroup`, and `request_device` now asks for no + features and no binding-array limits at all. `rigs/gpu-probe`, rewritten + to match, confirms `request_device` now succeeds on the emulator's + software Vulkan (`EMU_GPU=software`, SwiftShader) — see TEXTURES.md's + "Implemented, 2026-09-04" for the exact command and output, and for what + was verified (rendering, via `run-headless.sh`) versus what was reasoned + through but not separately stress-tested (a real second-atlas-page + grow under load). Nothing here has been run on real Android hardware + yet, only the emulator; the Android Vulkan Profile 2025 sourcing in + "iris's binding array does not survive real Android hardware" below is + what stands in for that until I2 gets a device. +- **Next**: **I2** — iris on android-view. **E2** (a transcript in + Masonry) can go in parallel in another session. - **Not started**: `client-core`, which is item 1 of the recommendation below and does not depend on the framework choice. Nothing has been built for it, and it is not one of the numbered boxes — worth picking up @@ -868,7 +874,12 @@ step measured. nightly gates — `portable_simd` (the old glyph compositing) and `gen_blocks` (the deleted line iterator). **Eleven left.** -### iris's binding array does not survive real Android hardware (found 2026-09-04) +### iris's binding array does not survive real Android hardware (found 2026-09-04, resolved 2026-09-04) + +**Resolved the same day**: see "Where things stand" above and +TEXTURES.md's "Implemented, 2026-09-04". The measurement and sourcing +below are unchanged and are why the fix looks the way it does; nothing +here needs re-checking on its own account. Iris asked, of the "unknown number of images" case — a transcript with an unbounded number of attached screenshots — whether iris's approach even diff --git a/TEXTURES.md b/TEXTURES.md index e38e5df..c49b7c6 100644 --- a/TEXTURES.md +++ b/TEXTURES.md @@ -1,5 +1,16 @@ # How iris should render an unbounded number of images +## Status (2026-09-04) + +**Implemented**, on the `rustify` branch of `ai-app-2`, in `iris/core` and +`iris/src/default/render.rs`. See "Implemented, 2026-09-04" at the bottom for +what landed, what differs from the proposal below and why, and what was +verified versus merely reasoned about. The short version: the binding array +is gone, `request_device` asks for no features and no binding-array limits, +and that is now proven on the emulator's software Vulkan +(`rigs/gpu-probe`), not just read from the code. `RUST.md`'s blocking item +is resolved. + Iris (the person) asked whether iris's (the library's) approach to "draw however many images happen to be on screen" — relevant here because a transcript can hold an unbounded number of attached screenshots — actually @@ -333,3 +344,140 @@ needs to know an image from a page (two kinds of handle, or a kind on `TextureHandle`), and `Primitives` gets a second instance list per layer. What it saves: the sort, the size threshold, the eviction policy, and any per-page bind group switch. + +## Implemented, 2026-09-04 + +The shape above, built as proposed with one structural addition the proposal +didn't need to spell out and one bug it predicted made moot rather than +literally fixed. Files: `core/src/primitive/texture.rs` (`Textures`, +`TextureHandle`), `core/src/render/texture.rs` (`GpuTextures`), +`core/src/render/primitive.rs` (`Primitives`, `GlyphPrimitive`), +`core/src/render/atlas.rs`, `core/src/ui/painter.rs`, +`core/src/render/mod.rs` (`UiRenderNode`, `UiLimits` removed), +`core/src/render/shader.wgsl`, `src/default/render.rs`, and +`rigs/gpu-probe/src/main.rs`. + +**1. Atlas pages as array layers.** `GpuTextures` owns one +`texture_2d_array` (`array_texture`/`array_view`), grown by doubling +(`grow_array`): a new texture is created at twice the layer capacity, the +old layers are copied across with `copy_texture_to_texture` (GPU-side, no +readback), and every bind group that referenced the old view — the main +one and every live standalone image's — is rebuilt, since the view's +identity changed. `GlyphPrimitive` carries `layer: u32` instead of +`view_idx`/`sampler_idx`; the layer number is assigned synchronously in +`Textures::add_page` (a plain counter, `next_page_layer`), not by the +renderer, because `GlyphAtlas::insert` needs it in the same call, before +any GPU sync happens — the renderer only finds out later, when it +processes the queued `Push`. + +**2. Standalone images, one bind group each.** `TextureKind` on +`TextureHandle`/`Textures` distinguishes `Image` (a plain bind-group index, +`slot`) from `Page { layer }`. `Primitives` gained a second per-layer list +— `images: Vec`, tagged `IMAGE_BINDING` — separate from +`instances` (rects and glyphs), written by `Painter::write_image` rather +than through the generic `Primitive` trait, since an image has nowhere in +`PrimitiveData` to put a per-instance entry once the bind group already +picks the texture. `UiRenderNode::draw` draws a layer's `instance` buffer +once as before, then walks `image_instance` one entry at a time, binding +that texture's `BindGroup` (`GpuTextures::image_bind_group`) and issuing +`draw(0..4, k..k+1)` per image. Group 2's layout is exactly the proposed +`{atlas array, one image texture, sampler, masks}`; the main draw binds a +1x1 null view in the image slot. + +**The one addition beyond the proposal**: the masks storage buffer lives +in every per-image bind group (group 2, binding 3), and `ArrBuf` +recreates its buffer whenever the mask count changes size +(`render/util/mod.rs`'s `ArrBuf::update` now returns whether it resized). +A resize invalidates every bind group holding the old buffer, not just the +main one, so `GpuTextures::update` takes a `masks_resized: bool` and calls +`rebuild_image_bind_groups` when it's set, alongside the same rebuild the +array-growth path already needed. This wasn't a design question the +proposal had to answer (it treated bind-group construction as a given), +but it's exactly the shape of trap layer growth already had, so it uses +the same fix. + +**3. No thumbnail atlas.** Not built, as proposed. + +**4. Removed**: `TEXTURE_BINDING_ARRAY`, `PARTIALLY_BOUND_BINDING_ARRAY`, +`SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING` from +`src/default/render.rs`'s `request_device`, and `UiLimits` (the type +itself, not just its binding-array methods — once its two fields were +gone there was nothing left in it, and `UiRenderNode::new` no longer takes +a limits parameter). `binding_array` no longer appears anywhere in +`shader.wgsl`. + +**5. Sampling** is still `NonFiltering`, unchanged, per the proposal's own +note that this is a separate decision for whenever the image widget itself +is touched. + +**The `changed = false` bug is structurally gone, not patched.** The old +`GpuTextures::update` held one `changed: bool` that a `Patch` reset +unconditionally, which could erase an earlier `Push` in the same batch (a +new atlas page's `Push` immediately followed by `GlyphAtlas::insert`'s +`Patch`, both queued before the renderer ever runs). The new `update` +computes the rebuild signal by OR-ing each event's own answer +(`rebuild_main |= self.push(...)`), and `Patch`'s arm simply never +contributes to it — there is no shared mutable flag left for a `Patch` to +stomp on. Documented at the call site +(`core/src/render/texture.rs`, `GpuTextures::update`'s doc comment and the +`Patch` match arm's comment) rather than fixed as a one-line diff, since +the mechanism that could go wrong no longer exists. + +**In-layer draw order is an explicit invariant now, not just a fact about +`swap_remove`.** `UiRenderNode::draw` draws every layer's images after its +rects and glyphs, and `Primitives::apply_free`'s doc comment states +directly that both of a layer's lists (`instances` and `images`) free with +`swap_remove` and that nothing may assume adjacency survives a free — +recorded there because `apply_free` is the one place a change to either +list's ordering would have to be reconciled. + +**Verified:** + +- `cargo fmt --all -- --check`, `cargo build --workspace --all-targets`, + `cargo clippy --all-targets`, `cargo test --workspace` all clean in + `iris/`, on the pinned `nightly-2026-09-03` toolchain. 14 tests pass + (unchanged from I1; nothing here is pure-logic enough to add a unit + test to — it's all GPU resource wiring). +- `iris/run-headless.sh minimal --shot /tmp/minimal.png` and + `iris/run-headless.sh tabs --shot /tmp/tabs.png`: both render correctly + on this VM's GPU (Venus) — `tabs`'s glyph-atlas text renders in every + panel, confirming `GlyphPrimitive.layer` addresses the array correctly. +- The standalone-image path specifically: a throwaway example (not + committed) with an `image(...)` widget as part of the root, run the same + way, rendered the image next to glyph-atlas text in one frame — + confirming a live `BindGroup` built by `GpuTextures::create_image` and + bound per-`draw()` call actually samples the right texture. `tabs`'s own + "image span" tab exercises the same widget but needs a click to reach, + which the headless compositor can't deliver (no seat devices, per I1's + own note on this file) — the throwaway example is what stood in for it. +- **Not separately stress-tested**: triggering a second atlas page (the + `grow_array` doubling-and-copy path) under a real glyph load large + enough to fill the first 1024x1024 page. The code path was reasoned + through and matches the existing single-page write exactly except for + the `z` origin and the extra copy, but nobody has watched a real + second-page grow happen on screen. Worth doing before trusting this + under a transcript with a large or unusual glyph set (many distinct + fonts/sizes, or a font with an unusually large character set). +- **The decisive check**, `rigs/gpu-probe` rewritten to request iris's new + (empty) feature/limit set and run on this checkout's own emulator + (`ai-app-2`, via `emu`), booted with `EMU_GPU=software` so the guest gets + a real Vulkan device (SwiftShader) rather than the `-gpu host` default, + which disables Vulkan in this VM entirely (`-feature -Vulkan`, because + gfxstream can't pair Venus with the real GPU here — worth remembering, + since the *default* `emu up` gives a device with **no** Vulkan adapter + at all, which reads exactly like the old bindless failure if you don't + know to ask for `EMU_GPU=software`): + + cd rigs/gpu-probe + ANDROID_NDK_HOME=$HOME/Android/Sdk/ndk/29.0.14206865 \ + cargo ndk -t arm64-v8a -P 26 build --release + EMU_GPU=software emu up # from ~/repos/emulator-tools + adb push target/aarch64-linux-android/release/gpu-probe /data/local/tmp/ + adb shell chmod 755 /data/local/tmp/gpu-probe + adb shell /data/local/tmp/gpu-probe + + Output: `adapters: 1 — Vulkan SwiftShader Device (Subzero) (Cpu)`, + `features iris requires:` (none listed — the set is empty), + `max_buffer_size … ok`, and **`IRIS DEVICE: ok`**. This is the fix + measured working, on the exact rig that first measured it failing. + Emulator stopped afterward (`emu down`); nothing was left running. diff --git a/iris/core/src/primitive/layer.rs b/iris/core/src/primitive/layer.rs index 54f6a96..5f62efd 100644 --- a/iris/core/src/primitive/layer.rs +++ b/iris/core/src/primitive/layer.rs @@ -1,6 +1,7 @@ use std::ops::{Index, IndexMut}; use crate::{ + UiRegion, WidgetId, render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives}, util::to_mut, }; @@ -131,6 +132,17 @@ impl PrimitiveLayers { pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx { self[h.layer].free(h) } + + pub fn write_image( + &mut self, + layer: LayerId, + id: WidgetId, + texture_idx: u32, + region: UiRegion, + mask_idx: MaskIdx, + ) -> PrimitiveHandle { + self[layer].write_image(layer, id, texture_idx, region, mask_idx) + } } impl Default for Layers { diff --git a/iris/core/src/primitive/texture.rs b/iris/core/src/primitive/texture.rs index 4fec782..8486c0b 100644 --- a/iris/core/src/primitive/texture.rs +++ b/iris/core/src/primitive/texture.rs @@ -1,19 +1,33 @@ -use crate::{ - render::TexturePrimitive, - util::{RefCounter, Vec2}, -}; +use crate::util::{RefCounter, Vec2}; use image::{DynamicImage, GenericImageView}; use std::{ ops::Index, sync::mpsc::{Receiver, Sender, channel}, }; +/// Which of the two things a texture slot holds. See TEXTURES.md's +/// "Recommended shape" for why these are drawn so differently: a page is a +/// layer of one shared array texture and never gets its own bind group; a +/// standalone image is the opposite, one texture and one bind group, never a +/// layer. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TextureKind { + Image, + /// The array-texture layer this page was assigned. Chosen synchronously + /// by `Textures::add_page` rather than by the renderer, because glyph + /// insertion needs it in the same call, before any GPU sync happens. + Page { + layer: u32, + }, +} + #[derive(Debug, Clone)] pub struct TextureHandle { - inner: TexturePrimitive, + slot: u32, + kind: TextureKind, size: Vec2, counter: RefCounter, - send: Sender, + send: Sender<(TextureKind, u32)>, } /// a texture manager for a ui @@ -21,20 +35,24 @@ pub struct TextureHandle { pub struct Textures { free: Vec, images: Vec>, + /// Next layer to hand out to an atlas page. Pages are never freed (no + /// atlas eviction), so this only grows and `free` never holds one. + next_page_layer: u32, updates: Vec, - send: Sender, - recv: Receiver, + send: Sender<(TextureKind, u32)>, + recv: Receiver<(TextureKind, u32)>, } pub enum TextureUpdate<'a> { - Push(&'a DynamicImage), - Set(u32, &'a DynamicImage), + Push(TextureKind, &'a DynamicImage), + Set(TextureKind, u32, &'a DynamicImage), /// Overwrite a rectangle of an existing texture, rather than replacing it. /// The glyph atlas grows a glyph at a time, and re-uploading a whole atlas /// per glyph is megabytes of copy for a few hundred bytes of change. + /// Only ever issued against a page -- a standalone image is never patched. Patch(u32, PatchRect, &'a DynamicImage), Free(u32), - PushFree, + PushFree(TextureKind), SetFree, } @@ -47,8 +65,8 @@ pub struct PatchRect { } enum Update { - Push(u32), - Set(u32), + Push(TextureKind, u32), + Set(TextureKind, u32), Patch(u32, PatchRect), Free(u32), } @@ -59,71 +77,95 @@ impl Textures { Self { free: Vec::new(), images: Vec::new(), + next_page_layer: 0, updates: Vec::new(), send, recv, } } + pub fn add(&mut self, image: impl Into) -> TextureHandle { let image = image.into(); let size = image.dimensions().into(); - let view_idx = self.push(image); - // 0 == default in renderer; TODO: actually create samplers here - let sampler_idx = 0; + let kind = TextureKind::Image; + let slot = self.push(kind, image); TextureHandle { - inner: TexturePrimitive { - view_idx, - sampler_idx, - }, + slot, + kind, size, counter: RefCounter::new(), send: self.send.clone(), } } - fn push(&mut self, image: DynamicImage) -> u32 { + /// Adds a page of the shared glyph atlas array. Only `atlas.rs` should + /// call this -- everything else wants `add`. + pub fn add_page(&mut self, image: impl Into) -> TextureHandle { + let image = image.into(); + let size = image.dimensions().into(); + let layer = self.next_page_layer; + self.next_page_layer += 1; + let kind = TextureKind::Page { layer }; + let slot = self.push(kind, image); + TextureHandle { + slot, + kind, + size, + counter: RefCounter::new(), + send: self.send.clone(), + } + } + + fn push(&mut self, kind: TextureKind, image: DynamicImage) -> u32 { if let Some(i) = self.free.pop() { self.images[i as usize] = Some(image); - self.updates.push(Update::Set(i)); + self.updates.push(Update::Set(kind, i)); i } else { let i = self.images.len() as u32; self.images.push(Some(image)); - self.updates.push(Update::Push(i)); + self.updates.push(Update::Push(kind, i)); i } } /// The stored image for a handle, to be written into before `patch`. pub fn image_mut(&mut self, handle: &TextureHandle) -> &mut DynamicImage { - self.images[handle.inner.view_idx as usize] + self.images[handle.slot as usize] .as_mut() .expect("texture was freed while still held") } /// Queue an upload of just `rect`, after writing it with `image_mut`. pub fn patch(&mut self, handle: &TextureHandle, rect: PatchRect) { - self.updates - .push(Update::Patch(handle.inner.view_idx, rect)); + self.updates.push(Update::Patch(handle.slot, rect)); } pub fn free(&mut self) { - for idx in self.recv.try_iter() { + for (kind, idx) in self.recv.try_iter() { self.images[idx as usize] = None; self.updates.push(Update::Free(idx)); - self.free.push(idx); + // A page's slot is never reclaimed: `GlyphAtlas` never drops the + // handles it holds, and there is no eviction path for a hole in + // the middle of the array's layers. If that ever changes, this + // is where a freed page's layer would need to go on a free list + // of its own, separate from `free`, which only ever holds + // ordinary image slots today. + if kind == TextureKind::Image { + self.free.push(idx); + } } } pub fn updates(&mut self) -> impl Iterator> { self.updates.drain(..).map(|u| match u { - Update::Push(i) => self.images[i as usize] + Update::Push(kind, i) => self.images[i as usize] .as_ref() - .map(TextureUpdate::Push) - .unwrap_or(TextureUpdate::PushFree), - Update::Set(i) => self.images[i as usize] + .map(|img| TextureUpdate::Push(kind, img)) + .unwrap_or(TextureUpdate::PushFree(kind)), + Update::Set(kind, i) => self.images[i as usize] .as_ref() - .map(|img| TextureUpdate::Set(i, img)) + .map(|img| TextureUpdate::Set(kind, i, img)) .unwrap_or(TextureUpdate::SetFree), Update::Patch(i, rect) => self.images[i as usize] .as_ref() @@ -135,18 +177,36 @@ impl Textures { } impl TextureHandle { - pub fn primitive(&self) -> TexturePrimitive { - self.inner - } pub fn size(&self) -> Vec2 { self.size } + + /// The bind-group index this handle draws with. Only valid for a + /// standalone image; an atlas page has no bind group of its own -- it + /// samples the shared array via `layer()` instead. Getting this wrong is + /// a caller bug (the wrong kind of handle reached the wrong draw path), + /// not a recoverable condition, so it panics rather than drawing garbage. + pub fn image_index(&self) -> u32 { + match self.kind { + TextureKind::Image => self.slot, + TextureKind::Page { .. } => panic!("image_index() called on an atlas page handle"), + } + } + + /// The layer this page occupies in the shared atlas array texture. + /// Only valid for a page handle; see `image_index`'s note. + pub fn layer(&self) -> u32 { + match self.kind { + TextureKind::Page { layer } => layer, + TextureKind::Image => panic!("layer() called on a standalone image handle"), + } + } } impl Drop for TextureHandle { fn drop(&mut self) { if self.counter.drop() { - let _ = self.send.send(self.inner.view_idx); + let _ = self.send.send((self.kind, self.slot)); } } } @@ -155,7 +215,7 @@ impl Index<&TextureHandle> for Textures { type Output = DynamicImage; fn index(&self, index: &TextureHandle) -> &Self::Output { - self.images[index.inner.view_idx as usize].as_ref().unwrap() + self.images[index.slot as usize].as_ref().unwrap() } } diff --git a/iris/core/src/render/atlas.rs b/iris/core/src/render/atlas.rs index a85d9ac..ec29a19 100644 --- a/iris/core/src/render/atlas.rs +++ b/iris/core/src/render/atlas.rs @@ -18,8 +18,10 @@ use swash::scale::image::{Content, Image}; /// Side of one atlas page, in pixels. 1024 is 4 MB at RGBA8 -- enough for a /// few thousand glyphs at UI sizes, and small enough that a page nobody fills -/// is not a big waste. -const PAGE: u32 = 1024; +/// is not a big waste. Also the fixed width/height of every layer of the +/// shared array texture in `render::texture` -- `pub(crate)` so that module +/// can size it without a second constant to keep in sync. +pub(crate) const PAGE: u32 = 1024; /// Transparent margin kept around every glyph, so that sampling one cannot /// pick up its neighbour along a shared edge. @@ -51,8 +53,8 @@ pub struct GlyphEntry { pub width: u32, pub height: u32, pub is_color: bool, - pub view_idx: u32, - pub sampler_idx: u32, + /// The atlas array layer this glyph's page occupies. + pub layer: u32, } struct Page { @@ -126,8 +128,7 @@ impl GlyphAtlas { width: w, height: h, is_color: matches!(image.content, Content::Color), - view_idx: page.handle.primitive().view_idx, - sampler_idx: page.handle.primitive().sampler_idx, + layer: page.handle.layer(), }; self.entries.insert(key, Some(entry)); Some(entry) @@ -150,7 +151,7 @@ impl GlyphAtlas { return (i, x, y); } - let handle = textures.add(RgbaImage::new(PAGE, PAGE)); + let handle = textures.add_page(RgbaImage::new(PAGE, PAGE)); self.pages.push(Page { handle, x: PAD + w + PAD, diff --git a/iris/core/src/render/mod.rs b/iris/core/src/render/mod.rs index e298230..87799eb 100644 --- a/iris/core/src/render/mod.rs +++ b/iris/core/src/render/mod.rs @@ -1,5 +1,3 @@ -use std::num::NonZero; - use crate::{ UiData, UiRenderState, render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf}, @@ -42,21 +40,44 @@ struct RenderLayer { instance: ArrBuf, primitives: PrimitiveBuffers, primitive_group: BindGroup, + /// A standalone image's instances, kept apart from `instance` because + /// each one draws with its own bind group -- see `UiRenderNode::draw`. + image_instance: ArrBuf, + /// The texture slot each entry of `image_instance` draws with, in the + /// same order, refreshed alongside it. Not stored in the vertex buffer + /// itself because it names a bind group, not shader data. + image_tex_indices: Vec, } impl UiRenderNode { pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) { pass.set_pipeline(&self.pipeline); pass.set_bind_group(0, &self.uniform_group, &[]); - pass.set_bind_group(2, &self.rsc_group, &[]); for i in &self.active { let layer = &self.layers[i]; - if layer.instance.len() == 0 { + if layer.instance.len() == 0 && layer.image_instance.len() == 0 { continue; } pass.set_bind_group(1, &layer.primitive_group, &[]); - pass.set_vertex_buffer(0, layer.instance.buffer.slice(..)); - pass.draw(0..4, 0..layer.instance.len() as u32); + if layer.instance.len() > 0 { + pass.set_bind_group(2, &self.rsc_group, &[]); + pass.set_vertex_buffer(0, layer.instance.buffer.slice(..)); + pass.draw(0..4, 0..layer.instance.len() as u32); + } + // Images draw after this layer's rects and glyphs, one draw call + // each with its own bind group. That draws every image "on top" + // within the layer, which loses nothing that currently exists: + // `Primitives::apply_free` frees with `swap_remove`, so a layer's + // draw order was already undefined before images had their own + // list -- nothing before this relied on interleaving a rect + // between two images at a particular position. + if layer.image_instance.len() > 0 { + pass.set_vertex_buffer(0, layer.image_instance.buffer.slice(..)); + for (k, &tex_idx) in layer.image_tex_indices.iter().enumerate() { + pass.set_bind_group(2, self.textures.image_bind_group(tex_idx), &[]); + pass.draw(0..4, k as u32..k as u32 + 1); + } + } } } @@ -73,7 +94,15 @@ impl UiRenderNode { for change in primitives.apply_free() { if let Some(inst) = ui_render.active.get_mut(&change.id) { for h in &mut inst.primitives { - if h.layer == i && h.inst_idx == change.old { + // `is_image` disambiguates: `instances` and `images` + // are separate lists with independent indices, so + // without it a rect's renumbering could be applied to + // an image handle that happened to share the same + // (layer, inst_idx). + if h.layer == i + && h.inst_idx == change.old + && (h.binding == IMAGE_BINDING) == change.is_image + { h.inst_idx = change.new; break; } @@ -92,6 +121,12 @@ impl UiRenderNode { ), primitives, primitive_group, + image_instance: ArrBuf::new( + device, + BufferUsages::VERTEX | BufferUsages::COPY_DST, + "image instance", + ), + image_tex_indices: Vec::new(), } }); if primitives.updated { @@ -104,17 +139,30 @@ impl UiRenderNode { &self.primitive_layout, rlayer.primitives.buffers(), ); + rlayer + .image_instance + .update(device, queue, primitives.image_instances()); + rlayer.image_tex_indices = primitives + .image_instances() + .iter() + .map(|inst| inst.idx) + .collect(); primitives.updated = false; } } - let mut changed = false; - changed |= self.textures.update(&mut ui.textures); - if ui.masks.changed { + let masks_resized = if ui.masks.changed { ui.masks.changed = false; - self.masks.update(device, queue, &ui.masks[..]); - changed = true; - } - if changed { + self.masks.update(device, queue, &ui.masks[..]) + } else { + false + }; + let rebuild_main = self.textures.update( + &mut ui.textures, + &self.rsc_layout, + &self.masks, + masks_resized, + ); + if rebuild_main { self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks); } } @@ -132,12 +180,7 @@ impl UiRenderNode { queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice)); } - pub fn new( - device: &Device, - queue: &Queue, - config: &SurfaceConfiguration, - limits: UiLimits, - ) -> Self { + pub fn new(device: &Device, queue: &Queue, config: &SurfaceConfiguration) -> Self { let shader = device.create_shader_module(ShaderModuleDescriptor { label: Some("UI Shape Shader"), source: ShaderSource::Wgsl(SHAPE_SHADER.into()), @@ -167,17 +210,15 @@ impl UiRenderNode { let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer); let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor { - entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| { - BindGroupLayoutEntry { - binding: i as u32, - visibility: ShaderStages::FRAGMENT, - ty: BindingType::Buffer { - ty: BufferBindingType::Storage { read_only: true }, - has_dynamic_offset: false, - min_binding_size: None, - }, - count: None, - } + entries: &PrimitiveBuffers::BINDINGS.map(|binding| BindGroupLayoutEntry { + binding, + visibility: ShaderStages::FRAGMENT, + ty: BindingType::Buffer { + ty: BufferBindingType::Storage { read_only: true }, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, }), label: Some("primitive"), }); @@ -189,7 +230,7 @@ impl UiRenderNode { "ui masks", ); - let rsc_layout = Self::rsc_layout(device, &limits); + let rsc_layout = Self::rsc_layout(device); let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks); let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor { @@ -279,7 +320,13 @@ impl UiRenderNode { }) } - fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout { + /// Group 2: the shared atlas array, one standalone-image slot (a null + /// view for the main draw, a real one for each image's own bind group -- + /// see `GpuTextures`), one sampler and the masks buffer. No `count` on + /// any entry: this needs nothing beyond plain Vulkan 1.0 / GLES + /// sampling, unlike the `binding_array` layout it replaced (see + /// TEXTURES.md's "Recommended shape"). + fn rsc_layout(device: &Device) -> BindGroupLayout { device.create_bind_group_layout(&BindGroupLayoutDescriptor { entries: &[ BindGroupLayoutEntry { @@ -287,20 +334,30 @@ impl UiRenderNode { visibility: ShaderStages::FRAGMENT, ty: BindingType::Texture { sample_type: TextureSampleType::Float { filterable: false }, - view_dimension: TextureViewDimension::D2, + view_dimension: TextureViewDimension::D2Array, multisampled: false, }, - count: Some(NonZero::new(limits.max_textures).unwrap()), + count: None, }, BindGroupLayoutEntry { binding: 1, visibility: ShaderStages::FRAGMENT, - ty: BindingType::Sampler(SamplerBindingType::NonFiltering), - count: Some(NonZero::new(limits.max_samplers).unwrap()), + ty: BindingType::Texture { + sample_type: TextureSampleType::Float { filterable: false }, + view_dimension: TextureViewDimension::D2, + multisampled: false, + }, + count: None, }, BindGroupLayoutEntry { binding: 2, visibility: ShaderStages::FRAGMENT, + ty: BindingType::Sampler(SamplerBindingType::NonFiltering), + count: None, + }, + BindGroupLayoutEntry { + binding: 3, + visibility: ShaderStages::FRAGMENT, ty: BindingType::Buffer { ty: BufferBindingType::Storage { read_only: true }, has_dynamic_offset: false, @@ -313,6 +370,8 @@ impl UiRenderNode { }) } + /// The main group: rects and glyphs never sample the image slot, so it + /// gets a 1x1 null view rather than any live standalone image's. fn rsc_group( device: &Device, layout: &BindGroupLayout, @@ -324,14 +383,18 @@ impl UiRenderNode { entries: &[ BindGroupEntry { binding: 0, - resource: BindingResource::TextureViewArray(&tex_manager.views()), + resource: BindingResource::TextureView(tex_manager.array_view()), }, BindGroupEntry { binding: 1, - resource: BindingResource::SamplerArray(&tex_manager.samplers()), + resource: BindingResource::TextureView(tex_manager.null_view()), }, BindGroupEntry { binding: 2, + resource: BindingResource::Sampler(tex_manager.sampler()), + }, + BindGroupEntry { + binding: 3, resource: masks.buffer.as_entire_binding(), }, ], @@ -343,26 +406,3 @@ impl UiRenderNode { self.textures.view_count() } } - -pub struct UiLimits { - max_textures: u32, - max_samplers: u32, -} - -impl Default for UiLimits { - fn default() -> Self { - Self { - max_textures: 100000, - max_samplers: 1000, - } - } -} - -impl UiLimits { - pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 { - self.max_textures + self.max_samplers - } - pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 { - self.max_samplers - } -} diff --git a/iris/core/src/render/primitive.rs b/iris/core/src/render/primitive.rs index b79a0e6..a283af3 100644 --- a/iris/core/src/render/primitive.rs +++ b/iris/core/src/render/primitive.rs @@ -15,6 +15,18 @@ pub struct Primitives { assoc: Vec, data: PrimitiveData, free: Vec, + + /// Standalone images, kept apart from `instances` because each one draws + /// with its own bind group rather than sharing the layer's one instanced + /// draw -- see TEXTURES.md's "Recommended shape". `idx` on each + /// `PrimitiveInstance` here is the texture's slot in `Textures`/ + /// `GpuTextures`, not an index into `data`; there is no per-image entry + /// in `data` because a bind group already picks the texture; nothing + /// left to look up per-instance. + images: Vec, + image_assoc: Vec, + image_free: Vec, + pub updated: bool, } @@ -25,11 +37,21 @@ impl Default for Primitives { assoc: Default::default(), data: Default::default(), free: Vec::new(), + images: Default::default(), + image_assoc: Default::default(), + image_free: Vec::new(), updated: true, } } } +/// The `binding` tag `Painter` writes on an image instance. Distinct from any +/// `Primitive::BINDING` because images have no `PrimitiveData` entry to key +/// one from -- a bind group already selects the texture -- so this only ever +/// has to match the shader's `TEXTURE` constant and flag "this instance lives +/// in `Primitives::images`, not `Primitives::instances`" to the code below. +pub const IMAGE_BINDING: u32 = 1; + pub trait Primitive: Pod { const BINDING: u32; fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec; @@ -54,6 +76,14 @@ macro_rules! primitives { impl PrimitiveBuffers { pub const LEN: usize = primitives!(@count $($name)*); + /// The group-1 binding number each primitive's storage buffer + /// sits at, in declaration order. Not `0..LEN`: a primitive's + /// `BINDING` also tags its instances for the shader's dispatch + /// switch, and a removed primitive (as `TEXTURE` was, once + /// images stopped needing a per-instance storage entry) can + /// leave a gap, so the pipeline layout has to ask for these + /// exact numbers rather than assuming they are contiguous. + pub const BINDINGS: [u32; Self::LEN] = [$(<$ty>::BINDING,)*]; pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] { [ $((<$ty>::BINDING, &self.$name.buffer),)* @@ -143,26 +173,103 @@ impl Primitives { PrimitiveHandle::new::

(layer, inst_i, i) } - /// returns (old index, new index) - pub fn apply_free(&mut self) -> impl Iterator { - self.free.sort_by(|a, b| b.cmp(a)); - self.free.drain(..).filter_map(|i| { - self.instances.swap_remove(i); - self.assoc.swap_remove(i); - if i == self.instances.len() { - return None; - } - let id = self.assoc[i]; - let old = self.instances.len(); - Some(PrimitiveChange { id, old, new: i }) - }) + /// Writes an image instance directly -- there is no `Primitive` impl for + /// it to go through `write`, since it has nowhere in `PrimitiveData` to + /// put a per-instance entry. `texture_idx` is the slot the bind group at + /// draw time is chosen from, carried in the otherwise-unused `idx` field. + pub fn write_image( + &mut self, + layer: usize, + id: WidgetId, + texture_idx: u32, + region: UiRegion, + mask_idx: MaskIdx, + ) -> PrimitiveHandle { + self.updated = true; + let inst = PrimitiveInstance { + region, + idx: texture_idx, + mask_idx, + binding: IMAGE_BINDING, + }; + let inst_i = if let Some(i) = self.image_free.pop() { + self.images[i] = inst; + self.image_assoc[i] = id; + i + } else { + let i = self.images.len(); + self.images.push(inst); + self.image_assoc.push(id); + i + }; + PrimitiveHandle { + layer, + inst_idx: inst_i, + data_idx: 0, + binding: IMAGE_BINDING, + } + } + + pub fn image_instances(&self) -> &Vec { + &self.images + } + + /// returns (old index, new index) for both lists this layer keeps -- + /// `PrimitiveChange::is_image` says which, since the two have separate + /// index spaces and `old`/`new` alone would collide between them. + /// + /// Both lists free with `swap_remove`, so a layer's draw order was + /// already undefined before images existed: nothing here may assume one + /// primitive stays adjacent to another once anything in the layer has + /// been freed. + pub fn apply_free(&mut self) -> Vec { + let mut changes = + Self::apply_free_list(&mut self.free, &mut self.instances, &mut self.assoc, false); + changes.extend(Self::apply_free_list( + &mut self.image_free, + &mut self.images, + &mut self.image_assoc, + true, + )); + changes + } + + fn apply_free_list( + free: &mut Vec, + instances: &mut Vec, + assoc: &mut Vec, + is_image: bool, + ) -> Vec { + free.sort_by(|a, b| b.cmp(a)); + free.drain(..) + .filter_map(|i| { + instances.swap_remove(i); + assoc.swap_remove(i); + if i == instances.len() { + return None; + } + let id = assoc[i]; + let old = instances.len(); + Some(PrimitiveChange { + id, + is_image, + old, + new: i, + }) + }) + .collect() } pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx { self.updated = true; - self.data.free(h.binding, h.data_idx); - self.free.push(h.inst_idx); - self.instances[h.inst_idx].mask_idx + if h.binding == IMAGE_BINDING { + self.image_free.push(h.inst_idx); + self.images[h.inst_idx].mask_idx + } else { + self.data.free(h.binding, h.data_idx); + self.free.push(h.inst_idx); + self.instances[h.inst_idx].mask_idx + } } pub fn data(&self) -> &PrimitiveData { @@ -175,12 +282,21 @@ impl Primitives { pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion { self.updated = true; - &mut self.instances[h.inst_idx].region + if h.binding == IMAGE_BINDING { + &mut self.images[h.inst_idx].region + } else { + &mut self.instances[h.inst_idx].region + } } } pub struct PrimitiveChange { pub id: WidgetId, + /// Which of `Primitives::instances`/`Primitives::images` this change + /// belongs to -- their `old`/`new` indices are independent, so a + /// consumer matching only on `(layer, inst_idx)` could apply an image's + /// renumbering to a rect's handle that happens to share the same index. + pub is_image: bool, pub old: usize, pub new: usize, } @@ -206,7 +322,6 @@ impl PrimitiveHandle { primitives!( rects: RectPrimitive => 0, - textures: TexturePrimitive => 1, glyphs: GlyphPrimitive => 2, ); @@ -230,33 +345,48 @@ impl RectPrimitive { } } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct TexturePrimitive { - pub view_idx: u32, - pub sampler_idx: u32, -} - -/// One glyph, drawn as a sub-rectangle of the glyph atlas. +/// One glyph, drawn as a sub-rectangle of the glyph atlas array. /// -/// Separate from `TexturePrimitive` because that one samples a whole texture: -/// text needs many quads sharing one atlas, which is the whole point of having -/// an atlas. `color` is the text colour and is multiplied by the atlas's alpha -/// for an ordinary mask glyph; a colour glyph (emoji) carries its own colour -/// and takes the atlas texel unchanged, which is what `IS_COLOR` selects. +/// `color` is the text colour and is multiplied by the atlas's alpha for an +/// ordinary mask glyph; a colour glyph (emoji) carries its own colour and +/// takes the atlas texel unchanged, which is what `IS_COLOR` selects. #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct GlyphPrimitive { pub uv_min: [f32; 2], pub uv_max: [f32; 2], - pub view_idx: u32, - pub sampler_idx: u32, + /// Layer of the shared atlas array texture this glyph's page occupies -- + /// not a bind-group or view index, since a page never gets one of its + /// own. See TEXTURES.md's "Recommended shape". + pub layer: u32, pub color: Color, pub flags: u32, + /// Pads this struct's Rust size to match WGSL's storage-buffer layout for + /// `GlyphInfo`: two `vec2` members give the struct an 8-byte + /// alignment, which rounds the WGSL size up to 32 bytes even though the + /// fields above only total 28. `bytemuck` does not check this for us. + _pad: u32, } impl GlyphPrimitive { pub const IS_COLOR: u32 = 1; + + pub fn new( + uv_min: [f32; 2], + uv_max: [f32; 2], + layer: u32, + color: Color, + flags: u32, + ) -> Self { + Self { + uv_min, + uv_max, + layer, + color, + flags, + _pad: 0, + } + } } pub struct PrimitiveVec { diff --git a/iris/core/src/render/shader.wgsl b/iris/core/src/render/shader.wgsl index 1e6df68..4606188 100644 --- a/iris/core/src/render/shader.wgsl +++ b/iris/core/src/render/shader.wgsl @@ -1,4 +1,7 @@ const RECT: u32 = 0u; +// TEXTURE has no entry in group 1: a standalone image draws with its own +// bind group (see UiRenderNode::draw), so there is nothing per-instance left +// to look up here -- the bind group already picked the texture. const TEXTURE: u32 = 1u; const GLYPH: u32 = 2u; @@ -6,8 +9,6 @@ const GLYPH: u32 = 2u; var window: WindowUniform; @group(1) @binding(RECT) var rects: array; -@group(1) @binding(TEXTURE) -var textures: array; @group(1) @binding(GLYPH) var glyphs: array; @@ -18,16 +19,13 @@ struct Rect { inner_radius: f32, } -struct TextureInfo { - view_idx: u32, - sampler_idx: u32, -} - struct GlyphInfo { uv_min: vec2, uv_max: vec2, - view_idx: u32, - sampler_idx: u32, + // Layer of the shared atlas array texture, not a view or bind-group + // index -- a page never gets its own bind group. See TEXTURES.md's + // "Recommended shape". + layer: u32, color: u32, flags: u32, } @@ -52,11 +50,21 @@ struct UiVec2 { abs: vec2, } +// The shared glyph atlas: every page is one layer. Growing it recreates this +// texture with headroom and copies the old layers across -- see +// GpuTextures::grow_array -- rather than the binding_array> +// this replaced, which needed VK_EXT_descriptor_indexing and does not survive +// a real share of Android GPUs (see TEXTURES.md). @group(2) @binding(0) -var views: binding_array>; +var atlas: texture_2d_array; +// One standalone image's texture. The main draw (rects and glyphs) binds a +// 1x1 null texture here, since neither samples it; each image draw call +// binds its own -- see UiRenderNode::draw. @group(2) @binding(1) -var samplers: binding_array; +var image_texture: texture_2d; @group(2) @binding(2) +var samp: sampler; +@group(2) @binding(3) var masks: array; struct WindowUniform { @@ -135,7 +143,7 @@ fn fs_main( color = draw_rounded_rect(region, rects[i]); } case TEXTURE: { - color = draw_texture(region, textures[i]); + color = draw_texture(region); } case GLYPH: { color = draw_glyph(region, glyphs[i]); @@ -158,14 +166,13 @@ fn fs_main( return color; } -// TODO: this seems really inefficient (per frag indexing)? -fn draw_texture(region: Region, info: TextureInfo) -> vec4 { - return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv); +fn draw_texture(region: Region) -> vec4 { + return textureSample(image_texture, samp, region.uv); } fn draw_glyph(region: Region, g: GlyphInfo) -> vec4 { let uv = mix(g.uv_min, g.uv_max, region.uv); - let texel = textureSample(views[g.view_idx], samplers[g.sampler_idx], uv); + let texel = textureSample(atlas, samp, uv, i32(g.layer)); if (g.flags & 1u) != 0u { return texel; } diff --git a/iris/core/src/render/texture.rs b/iris/core/src/render/texture.rs index 5c44ef0..0ae5642 100644 --- a/iris/core/src/render/texture.rs +++ b/iris/core/src/render/texture.rs @@ -1,69 +1,165 @@ use image::{DynamicImage, EncodableLayout, GenericImageView}; use wgpu::{util::DeviceExt, *}; -use crate::{PatchRect, TextureUpdate, Textures}; +use crate::{Mask, PatchRect, TextureKind, TextureUpdate, Textures, render::util::ArrBuf}; +use super::atlas::PAGE; + +/// What one texture slot is, GPU-side. Parallel to `Textures`' own slot +/// numbering (`TextureKind`'s `Image`/`Page`), so a slot's index means the +/// same thing on both sides without a second map to keep in sync. +enum Slot { + /// A slot that was freed, or pushed and freed within the same batch + /// before ever reaching here. + Empty, + Image(ImageGpu), + /// The array layer a page occupies. Pages are never freed (see + /// `Textures::free`), so this is the only variant that outlives a `Free`. + Page(u32), +} + +struct ImageGpu { + /// Kept alive alongside `view`/`bind_group`, which borrow from it only in + /// the sense that dropping this drops the GPU resource they point to. + #[allow(dead_code)] + texture: Texture, + view: TextureView, + bind_group: BindGroup, +} + +/// Owns the two kinds of texture iris draws: +/// +/// - **The glyph atlas**, one `texture_2d_array` whose layers are pages +/// (`Slot::Page`), grown by recreating the array with headroom and +/// `copy_texture_to_texture`-ing the old layers across. No feature beyond +/// Vulkan 1.0/GLES sampling is needed for this -- a layer index is an +/// ordinary sampling operand. +/// - **Standalone images** (`Slot::Image`), each its own `Texture` and +/// `BindGroup`, drawn one `draw()` call at a time with that bind group +/// bound -- see `UiRenderNode::draw`. +/// +/// See TEXTURES.md's "Recommended shape" for why, and RUST.md's +/// "iris's binding array does not survive real Android hardware" for what +/// this replaced (one giant `binding_array>` needing +/// `VK_EXT_descriptor_indexing`, which a real share of Android GPUs lack). pub struct GpuTextures { device: Device, queue: Queue, - /// Kept alongside the views because a patch writes into the texture, and a - /// view cannot be written through. Parallel to `views`; `None` where the - /// slot is the shared null view. - textures: Vec>, - views: Vec, - view_count: usize, - samplers: Vec, + + slots: Vec, + + array_texture: Texture, + array_view: TextureView, + array_capacity: u32, + /// Layers actually written. Only grows -- see `Slot::Page`. + page_count: u32, + + sampler: Sampler, + /// Bound in the image slot of the main draw's bind group, which has + /// nothing of its own to put there: rects and glyphs never sample it, + /// but the layout requires something bound regardless. null_view: TextureView, - no_views: Vec, } impl GpuTextures { - pub fn update(&mut self, textures: &mut Textures) -> bool { - let mut changed = false; + /// Applies queued `Textures` updates, then reports whether the *main* + /// bind group (the one rects and glyphs draw with) needs rebuilding -- + /// true when the atlas array was recreated (its view identity changed) + /// or the masks buffer was, since both are bound there. Pushing or + /// freeing a standalone image never touches that group: it built or drops + /// its own. + pub fn update( + &mut self, + textures: &mut Textures, + rsc_layout: &BindGroupLayout, + masks: &ArrBuf, + masks_resized: bool, + ) -> bool { + let mut rebuild_main = masks_resized; + if masks_resized { + // The masks buffer just moved, so every bind group holding a + // reference to it -- one per live standalone image -- is stale. + self.rebuild_image_bind_groups(rsc_layout, masks); + } for update in textures.updates() { - changed = true; match update { - TextureUpdate::Push(image) => self.push(image), - TextureUpdate::Set(i, image) => self.set(i, image), - TextureUpdate::Patch(i, rect, image) => { - // A patch changes texture contents, not the binding array, - // so it must not report `changed` -- rebuilding the bind - // group per glyph is the cost this exists to avoid. - self.patch(i, rect, image); - changed = false; + TextureUpdate::Push(kind, image) => { + rebuild_main |= self.push(kind, image, rsc_layout, masks); } - TextureUpdate::SetFree => self.view_count += 1, + TextureUpdate::Set(kind, i, image) => { + rebuild_main |= self.set(kind, i, image, rsc_layout, masks); + } + // A patch changes texture contents, not which layer or bind + // group exists, so it never asks for a rebuild -- rebuilding + // per glyph is exactly the cost this exists to avoid. + TextureUpdate::Patch(i, rect, image) => self.patch(i, rect, image), + TextureUpdate::SetFree => {} TextureUpdate::Free(i) => self.free(i), - TextureUpdate::PushFree => self.push_free(), + TextureUpdate::PushFree(_kind) => self.slots.push(Slot::Empty), } } - changed + rebuild_main } - fn set(&mut self, i: u32, image: &DynamicImage) { - self.view_count += 1; - let (texture, view) = self.create(image); - self.textures[i as usize] = Some(texture); - self.views[i as usize] = view; + + fn push( + &mut self, + kind: TextureKind, + image: &DynamicImage, + rsc_layout: &BindGroupLayout, + masks: &ArrBuf, + ) -> bool { + let (slot, rebuilt) = self.make_slot(kind, image, rsc_layout, masks); + self.slots.push(slot); + rebuilt } + + fn set( + &mut self, + kind: TextureKind, + i: u32, + image: &DynamicImage, + rsc_layout: &BindGroupLayout, + masks: &ArrBuf, + ) -> bool { + let (slot, rebuilt) = self.make_slot(kind, image, rsc_layout, masks); + self.slots[i as usize] = slot; + rebuilt + } + + fn make_slot( + &mut self, + kind: TextureKind, + image: &DynamicImage, + rsc_layout: &BindGroupLayout, + masks: &ArrBuf, + ) -> (Slot, bool) { + match kind { + TextureKind::Image => { + let gpu = self.create_image(image, rsc_layout, masks); + (Slot::Image(gpu), false) + } + TextureKind::Page { layer } => { + let mut rebuilt = false; + if layer >= self.array_capacity { + self.grow_array(rsc_layout, masks); + rebuilt = true; + } + self.write_full_layer(layer, image); + self.page_count = self.page_count.max(layer + 1); + (Slot::Page(layer), rebuilt) + } + } + } + fn free(&mut self, i: u32) { - self.view_count -= 1; - self.textures[i as usize] = None; - self.views[i as usize] = self.null_view.clone(); - } - fn push(&mut self, image: &DynamicImage) { - self.view_count += 1; - let (texture, view) = self.create(image); - self.textures.push(Some(texture)); - self.views.push(view); - } - fn push_free(&mut self) { - self.view_count += 1; - self.textures.push(None); - self.views.push(self.null_view.clone()); + if let Some(slot) = self.slots.get_mut(i as usize) { + *slot = Slot::Empty; + } + // A page's layer is not reclaimed here either -- see `Slot::Page`. } fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) { - let Some(texture) = &self.textures[i as usize] else { + let Some(&Slot::Page(layer)) = self.slots.get(i as usize) else { return; }; if rect.width == 0 || rect.height == 0 { @@ -77,12 +173,12 @@ impl GpuTextures { .to_image(); self.queue.write_texture( TexelCopyTextureInfo { - texture, + texture: &self.array_texture, mip_level: 0, origin: Origin3d { x: rect.x, y: rect.y, - z: 0, + z: layer, }, aspect: TextureAspect::All, }, @@ -100,13 +196,105 @@ impl GpuTextures { ); } - fn create(&self, image: &DynamicImage) -> (Texture, TextureView) { - let image = image.to_rgba8(); - let (width, height) = image.dimensions(); + fn write_full_layer(&self, layer: u32, image: &DynamicImage) { + // Every page is created as exactly PAGE x PAGE (`GlyphAtlas::allocate`), + // so this is always a whole-layer write, never a crop. + let rgba = image.to_rgba8(); + self.queue.write_texture( + TexelCopyTextureInfo { + texture: &self.array_texture, + mip_level: 0, + origin: Origin3d { + x: 0, + y: 0, + z: layer, + }, + aspect: TextureAspect::All, + }, + rgba.as_bytes(), + TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(PAGE * 4), + rows_per_image: Some(PAGE), + }, + Extent3d { + width: PAGE, + height: PAGE, + depth_or_array_layers: 1, + }, + ); + } + + /// Doubles the array's layer capacity (headroom, so this is rare) and + /// copies the old layers across GPU-side -- no readback. Recreates the + /// array's view, which invalidates every bind group that referenced it, + /// so this also rebuilds all of them before returning. + fn grow_array(&mut self, rsc_layout: &BindGroupLayout, masks: &ArrBuf) { + let new_capacity = self.array_capacity * 2; + let new_texture = Self::create_array_texture(&self.device, new_capacity); + if self.page_count > 0 { + let mut encoder = self + .device + .create_command_encoder(&CommandEncoderDescriptor { + label: Some("atlas array grow"), + }); + encoder.copy_texture_to_texture( + TexelCopyTextureInfo { + texture: &self.array_texture, + mip_level: 0, + origin: Origin3d::ZERO, + aspect: TextureAspect::All, + }, + TexelCopyTextureInfo { + texture: &new_texture, + mip_level: 0, + origin: Origin3d::ZERO, + aspect: TextureAspect::All, + }, + Extent3d { + width: PAGE, + height: PAGE, + depth_or_array_layers: self.page_count, + }, + ); + self.queue.submit(std::iter::once(encoder.finish())); + } + self.array_texture = new_texture; + self.array_view = self.array_texture.create_view(&TextureViewDescriptor { + dimension: Some(TextureViewDimension::D2Array), + ..Default::default() + }); + self.array_capacity = new_capacity; + self.rebuild_image_bind_groups(rsc_layout, masks); + } + + fn rebuild_image_bind_groups(&mut self, rsc_layout: &BindGroupLayout, masks: &ArrBuf) { + for slot in &mut self.slots { + if let Slot::Image(gpu) = slot { + gpu.bind_group = Self::make_image_bind_group( + &self.device, + rsc_layout, + &self.array_view, + &gpu.view, + &self.sampler, + masks, + ); + } + } + } + + fn create_image( + &self, + image: &DynamicImage, + rsc_layout: &BindGroupLayout, + masks: &ArrBuf, + ) -> ImageGpu { + let rgba = image.to_rgba8(); + let (width, height) = rgba.dimensions(); let texture = self.device.create_texture_with_data( &self.queue, &TextureDescriptor { - label: None, + label: Some("image"), size: Extent3d { width, height, @@ -120,43 +308,138 @@ impl GpuTextures { view_formats: &[], }, wgt::TextureDataOrder::MipMajor, - image.as_bytes(), + rgba.as_bytes(), ); let view = texture.create_view(&TextureViewDescriptor::default()); - (texture, view) + let bind_group = Self::make_image_bind_group( + &self.device, + rsc_layout, + &self.array_view, + &view, + &self.sampler, + masks, + ); + ImageGpu { + texture, + view, + bind_group, + } + } + + /// Builds group 2 for one standalone image: the shared atlas array, this + /// image's own view, the shared sampler, and the shared masks buffer -- + /// the same layout the main draw uses with a null view in the image slot. + fn make_image_bind_group( + device: &Device, + rsc_layout: &BindGroupLayout, + array_view: &TextureView, + image_view: &TextureView, + sampler: &Sampler, + masks: &ArrBuf, + ) -> BindGroup { + device.create_bind_group(&BindGroupDescriptor { + layout: rsc_layout, + entries: &[ + BindGroupEntry { + binding: 0, + resource: BindingResource::TextureView(array_view), + }, + BindGroupEntry { + binding: 1, + resource: BindingResource::TextureView(image_view), + }, + BindGroupEntry { + binding: 2, + resource: BindingResource::Sampler(sampler), + }, + BindGroupEntry { + binding: 3, + resource: masks.buffer.as_entire_binding(), + }, + ], + label: Some("ui rsc image"), + }) + } + + fn create_array_texture(device: &Device, capacity: u32) -> Texture { + device.create_texture(&TextureDescriptor { + label: Some("glyph atlas array"), + size: Extent3d { + width: PAGE, + height: PAGE, + depth_or_array_layers: capacity, + }, + mip_level_count: 1, + sample_count: 1, + dimension: TextureDimension::D2, + format: TextureFormat::Rgba8Unorm, + usage: TextureUsages::TEXTURE_BINDING + | TextureUsages::COPY_DST + | TextureUsages::COPY_SRC, + view_formats: &[], + }) } pub fn new(device: &Device, queue: &Queue) -> Self { + let sampler = default_sampler(device); let null_view = null_texture_view(device); + let array_capacity = 1; + let array_texture = Self::create_array_texture(device, array_capacity); + let array_view = array_texture.create_view(&TextureViewDescriptor { + dimension: Some(TextureViewDimension::D2Array), + ..Default::default() + }); Self { device: device.clone(), queue: queue.clone(), - textures: Vec::new(), - views: Vec::new(), - samplers: vec![default_sampler(device)], - no_views: vec![null_view.clone()], + slots: Vec::new(), + array_texture, + array_view, + array_capacity, + page_count: 0, + sampler, null_view, - view_count: 0, } } - pub fn views(&self) -> Vec<&TextureView> { - if self.views.is_empty() { - &self.no_views - } else { - &self.views - } - .iter() - .by_ref() - .collect() + pub fn array_view(&self) -> &TextureView { + &self.array_view } - pub fn samplers(&self) -> Vec<&Sampler> { - self.samplers.iter().by_ref().collect() + pub fn null_view(&self) -> &TextureView { + &self.null_view + } + + pub fn sampler(&self) -> &Sampler { + &self.sampler + } + + /// The bind group a standalone image draws with. Panics if `idx` names an + /// atlas page or a freed slot instead -- either is a caller bug (the + /// wrong kind of instance reached this draw path), not a condition to + /// recover from. + pub fn image_bind_group(&self, idx: u32) -> &BindGroup { + match self.slots.get(idx as usize) { + Some(Slot::Image(gpu)) => &gpu.bind_group, + other => panic!("texture slot {idx} is not a live standalone image: {other:?}"), + } } pub fn view_count(&self) -> usize { - self.view_count + self.slots + .iter() + .filter(|s| !matches!(s, Slot::Empty)) + .count() + } +} + +impl std::fmt::Debug for Slot { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Slot::Empty => write!(f, "Empty"), + Slot::Image(_) => write!(f, "Image"), + Slot::Page(layer) => write!(f, "Page(layer={layer})"), + } } } diff --git a/iris/core/src/render/util/mod.rs b/iris/core/src/render/util/mod.rs index c9d48ff..d4faf54 100644 --- a/iris/core/src/render/util/mod.rs +++ b/iris/core/src/render/util/mod.rs @@ -21,13 +21,18 @@ impl ArrBuf { _pd: PhantomData, } } - pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) { - if self.len != data.len() { + /// Returns whether the underlying `Buffer` was recreated -- a caller that + /// cached a `BindGroup` referencing it (as `GpuTextures` does for the + /// masks buffer) needs to know to rebuild that too. + pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) -> bool { + let resized = self.len != data.len(); + if resized { self.len = data.len(); self.buffer = Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label); } queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data)); + resized } fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer { let mut size = size as u64; diff --git a/iris/core/src/ui/painter.rs b/iris/core/src/ui/painter.rs index 380a819..9ec455c 100644 --- a/iris/core/src/ui/painter.rs +++ b/iris/core/src/ui/painter.rs @@ -77,17 +77,31 @@ impl<'a> Painter<'a> { pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) { self.textures.push(handle.clone()); - self.primitive_at(handle.primitive(), region.within(&self.region)); + self.write_image(handle.image_index(), region.within(&self.region)); } pub fn texture(&mut self, handle: &TextureHandle) { self.textures.push(handle.clone()); - self.primitive(handle.primitive()); + self.write_image(handle.image_index(), self.region); } pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) { self.textures.push(handle.clone()); - self.primitive_at(handle.primitive(), region); + self.write_image(handle.image_index(), region); + } + + /// A standalone image draws with its own bind group rather than sharing + /// the layer's one instanced draw, so it goes through + /// `Primitives::write_image` instead of `primitive_at`/`Primitive::vec`. + fn write_image(&mut self, texture_idx: u32, region: UiRegion) { + let h = self + .state + .layers + .write_image(self.layer, self.id, texture_idx, region, self.mask); + if self.mask != MaskIdx::NONE { + self.rsc.ui_mut().masks.push_ref(self.mask); + } + self.primitives.push(h); } pub fn render_text( @@ -121,14 +135,13 @@ impl<'a> Painter<'a> { region.x.end = region.x.start + UiScalar::abs(glyph.entry.width as f32); region.y.end = region.y.start + UiScalar::abs(glyph.entry.height as f32); self.primitive_at( - GlyphPrimitive { - uv_min: glyph.entry.uv_min, - uv_max: glyph.entry.uv_max, - view_idx: glyph.entry.view_idx, - sampler_idx: glyph.entry.sampler_idx, - color: text.color, - flags: flags_for(glyph.entry.is_color), - }, + GlyphPrimitive::new( + glyph.entry.uv_min, + glyph.entry.uv_max, + glyph.entry.layer, + text.color, + flags_for(glyph.entry.is_color), + ), region, ); } diff --git a/iris/src/default/render.rs b/iris/src/default/render.rs index 0004dd1..3be551c 100644 --- a/iris/src/default/render.rs +++ b/iris/src/default/render.rs @@ -1,4 +1,4 @@ -use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState}; +use iris_core::{UiData, UiRenderNode, UiRenderState}; use pollster::FutureExt; use std::sync::Arc; use wgpu::*; @@ -89,18 +89,16 @@ impl UiRenderer { .block_on() .expect("Could not get adapter!"); - let ui_limits = UiLimits::default(); - + // No features beyond what wgpu asks for by default, and no + // binding-array limits: the atlas is one texture_2d_array and a + // standalone image is its own ordinary bind group, neither of which + // needs descriptor indexing. See TEXTURES.md's "Recommended shape" + // for why the old binding array asked for + // VK_EXT_descriptor_indexing unconditionally and did not survive a + // real share of Android GPUs. let (device, queue) = adapter .request_device(&DeviceDescriptor { - required_features: Features::TEXTURE_BINDING_ARRAY - | Features::PARTIALLY_BOUND_BINDING_ARRAY - | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING, required_limits: Limits { - max_binding_array_elements_per_shader_stage: ui_limits - .max_binding_array_elements_per_shader_stage(), - max_binding_array_sampler_elements_per_shader_stage: ui_limits - .max_binding_array_sampler_elements_per_shader_stage(), max_buffer_size: 1 << 30, ..Default::default() }, @@ -137,7 +135,7 @@ impl UiRenderer { let encoder = Self::create_encoder(&device); - let ui = UiRenderNode::new(&device, &queue, &config, ui_limits); + let ui = UiRenderNode::new(&device, &queue, &config); Self { surface, diff --git a/rigs/gpu-probe/src/main.rs b/rigs/gpu-probe/src/main.rs index 1643e6b..a15f977 100644 --- a/rigs/gpu-probe/src/main.rs +++ b/rigs/gpu-probe/src/main.rs @@ -1,11 +1,19 @@ //! Ask a device whether it can give iris the GPU it asks for. //! -//! iris's renderer binds every texture it has drawn as one binding array and -//! indexes it non-uniformly from the shader, which needs descriptor indexing -//! and a very large per-stage binding-array limit (101,000 elements: 100,000 -//! textures and 1,000 samplers, `UiLimits::default`). Those are ordinary on a -//! desktop and not obviously available on a phone, so this reports what the -//! adapter offers before anything is built on the assumption. +//! Until 2026-09-04 iris's renderer bound every texture it had drawn as one +//! binding array and indexed it non-uniformly from the shader, which needed +//! descriptor indexing and a very large per-stage binding-array limit +//! (101,000 elements: 100,000 textures and 1,000 samplers, +//! `UiLimits::default`). That was ordinary on a desktop and, per +//! TEXTURES.md's "iris's binding array does not survive real Android +//! hardware", not available on a real share of Android GPUs -- and it failed +//! outright on this emulator's software Vulkan, which is what this rig +//! caught first. iris now asks for nothing beyond wgpu's own defaults (see +//! `iris/src/default/render.rs`): the glyph atlas is one `texture_2d_array` +//! and a standalone image is its own ordinary bind group, and neither needs +//! descriptor indexing. This rig still asks `request_device` for exactly +//! what iris asks for, so it keeps being the answer to "does iris's actual +//! device request succeed here" rather than a guess from reading the code. //! //! It runs as a plain executable with no window and no APK, because //! `request_adapter` needs no surface -- so it can be pushed to a device with @@ -17,16 +25,15 @@ mod vk; use wgpu::*; -/// What `iris/src/default/render.rs` asks `request_device` for. +/// What `iris/src/default/render.rs` asks `request_device` for, now that the +/// binding array is gone: nothing beyond wgpu's own default feature set. fn iris_features() -> Features { - Features::TEXTURE_BINDING_ARRAY - | Features::PARTIALLY_BOUND_BINDING_ARRAY - | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING + Features::empty() } -/// `UiLimits::default()`: 100,000 textures + 1,000 samplers. -const IRIS_MAX_BINDING_ARRAY: u32 = 101_000; -const IRIS_MAX_BINDING_ARRAY_SAMPLERS: u32 = 1_000; +/// The one non-default limit iris asks for -- unrelated to the binding array, +/// kept for the big storage buffers behind rects/glyphs. +const IRIS_MAX_BUFFER_SIZE: u64 = 1 << 30; fn main() { vk::report(); @@ -80,75 +87,37 @@ fn main() { let limits = adapter.limits(); println!("\nlimits iris requires:"); - for (name, want, got) in [ - ( - "max_binding_array_elements_per_shader_stage", - IRIS_MAX_BINDING_ARRAY, - limits.max_binding_array_elements_per_shader_stage, - ), - ( - "max_binding_array_sampler_elements_per_shader_stage", - IRIS_MAX_BINDING_ARRAY_SAMPLERS, - limits.max_binding_array_sampler_elements_per_shader_stage, - ), - ] { - println!( - " {name:52} want {want:>7} have {got:>7} {}", - if got >= want { "ok" } else { "TOO SMALL" } - ); - } println!( - " {:52} want {:>7} have {:>7}", - "max_buffer_size (iris asks 1<<30)", - 1u64 << 30, - limits.max_buffer_size + " {:52} want {:>7} have {:>7} {}", + "max_buffer_size", + IRIS_MAX_BUFFER_SIZE, + limits.max_buffer_size, + if limits.max_buffer_size >= IRIS_MAX_BUFFER_SIZE { + "ok" + } else { + "TOO SMALL" + } ); // The question that actually matters: does the device iris builds come - // back, or does wgpu refuse it? - let mut wanted = Limits { - max_binding_array_elements_per_shader_stage: IRIS_MAX_BINDING_ARRAY, - max_binding_array_sampler_elements_per_shader_stage: IRIS_MAX_BINDING_ARRAY_SAMPLERS, - max_buffer_size: 1 << 30, + // back, or does wgpu refuse it? With no features and no binding-array + // limits requested, this is expected to succeed everywhere -- this rig + // is what turned that from an assumption into a measurement, first on + // this emulator's software Vulkan. + let wanted = Limits { + max_buffer_size: IRIS_MAX_BUFFER_SIZE, ..Default::default() }; match pollster::block_on(adapter.request_device(&DeviceDescriptor { required_features: iris_features(), - required_limits: wanted.clone(), + required_limits: wanted, ..Default::default() })) { Ok(_) => println!("\nIRIS DEVICE: ok"), Err(e) => println!("\nIRIS DEVICE: FAILED -- {e}"), } - // If it failed, say how far down it has to be turned before it works, so - // the report names a number to design against rather than just "no". - if missing.is_empty() { - for cap in [ - limits.max_binding_array_elements_per_shader_stage, - 1024, - 128, - 16, - ] { - if cap >= IRIS_MAX_BINDING_ARRAY { - continue; - } - wanted.max_binding_array_elements_per_shader_stage = cap; - wanted.max_binding_array_sampler_elements_per_shader_stage = - cap.min(IRIS_MAX_BINDING_ARRAY_SAMPLERS); - let ok = pollster::block_on(adapter.request_device(&DeviceDescriptor { - required_features: iris_features(), - required_limits: wanted.clone(), - ..Default::default() - })) - .is_ok(); - println!( - " binding array capped at {cap:>7}: {}", - if ok { "ok" } else { "no" } - ); - if ok { - break; - } - } + if !missing.is_empty() { + println!("\nmissing features: {missing:?}"); } } From bc3db183e3a6c708a69e86057ff5ab8468e3d9df Mon Sep 17 00:00:00 2001 From: iris <2+iris@noreply.localhost> Date: Fri, 4 Sep 2026 22:40:15 -0400 Subject: [PATCH 23/77] Extract the event model into its own crate, shared with client-core RUST.md's recommendation item 1 starts here: Event, QuestionOption, SessionStatus, ImageRef, AttachmentRef, SeqEvent, context_tokens and context_after move to a new event-model crate so a future Rust client shares one definition with server/ instead of Events.kt's hand-kept mirror. session/driver.rs and session/transcript.rs re-export everything they used to define, so nothing downstream of either module changed. cargo test (127 passed), clippy --all-targets and fmt clean in both server/ and event-model/. Co-Authored-By: Claude Sonnet --- event-model/Cargo.lock | 107 +++++ event-model/Cargo.toml | 20 + event-model/src/lib.rs | 377 ++++++++++++++++++ event-model/target/.rustc_info.json | 1 + event-model/target/CACHEDIR.TAG | 3 + event-model/target/debug/.cargo-artifact-lock | 0 event-model/target/debug/.cargo-build-lock | 0 event-model/target/debug/.cargo-lock | 0 .../dep-lib-event_model | Bin 0 -> 30 bytes .../invoked.timestamp | 1 + .../lib-event_model | 1 + .../lib-event_model.json | 1 + .../itoa-e940bf7c9c083c64/dep-lib-itoa | Bin 0 -> 14 bytes .../itoa-e940bf7c9c083c64/invoked.timestamp | 1 + .../itoa-e940bf7c9c083c64/lib-itoa | 1 + .../itoa-e940bf7c9c083c64/lib-itoa.json | 1 + .../memchr-55c8f9bd116d57f0/dep-lib-memchr | Bin 0 -> 14 bytes .../memchr-55c8f9bd116d57f0/invoked.timestamp | 1 + .../memchr-55c8f9bd116d57f0/lib-memchr | 1 + .../memchr-55c8f9bd116d57f0/lib-memchr.json | 1 + .../dep-lib-proc_macro2 | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../lib-proc_macro2 | 1 + .../lib-proc_macro2.json | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../quote-096835ab63739f47/invoked.timestamp | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../quote-f95d225106368b84/dep-lib-quote | Bin 0 -> 14 bytes .../quote-f95d225106368b84/invoked.timestamp | 1 + .../quote-f95d225106368b84/lib-quote | 1 + .../quote-f95d225106368b84/lib-quote.json | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../serde-4f0323fc6c5c4c08/dep-lib-serde | Bin 0 -> 69 bytes .../serde-4f0323fc6c5c4c08/invoked.timestamp | 1 + .../serde-4f0323fc6c5c4c08/lib-serde | 1 + .../serde-4f0323fc6c5c4c08/lib-serde.json | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../serde-f06f4da0f75e7ba8/invoked.timestamp | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../dep-lib-serde_core | Bin 0 -> 74 bytes .../invoked.timestamp | 1 + .../lib-serde_core | 1 + .../lib-serde_core.json | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../dep-lib-serde_derive | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../lib-serde_derive | 1 + .../lib-serde_derive.json | 1 + .../dep-lib-serde_json | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../lib-serde_json | 1 + .../lib-serde_json.json | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../syn-ba824d1fb7fccb81/dep-lib-syn | Bin 0 -> 14 bytes .../syn-ba824d1fb7fccb81/invoked.timestamp | 1 + .../.fingerprint/syn-ba824d1fb7fccb81/lib-syn | 1 + .../syn-ba824d1fb7fccb81/lib-syn.json | 1 + .../dep-lib-unicode_ident | Bin 0 -> 14 bytes .../invoked.timestamp | 1 + .../lib-unicode_ident | 1 + .../lib-unicode_ident.json | 1 + .../run-build-script-build-script-build | 1 + .../run-build-script-build-script-build.json | 1 + .../build-script-build-script-build | 1 + .../build-script-build-script-build.json | 1 + .../dep-build-script-build-script-build | Bin 0 -> 14 bytes .../zmij-b8e41156ec2eb9b9/invoked.timestamp | 1 + .../zmij-dac683281b28ed51/dep-lib-zmij | Bin 0 -> 14 bytes .../zmij-dac683281b28ed51/invoked.timestamp | 1 + .../zmij-dac683281b28ed51/lib-zmij | 1 + .../zmij-dac683281b28ed51/lib-zmij.json | 1 + .../debug/deps/event_model-22939ccd17cf0d53.d | 7 + .../target/debug/deps/itoa-e940bf7c9c083c64.d | 8 + .../deps/libevent_model-22939ccd17cf0d53.rlib | Bin 0 -> 707862 bytes .../libevent_model-22939ccd17cf0d53.rmeta | Bin 0 -> 615182 bytes .../debug/deps/libitoa-e940bf7c9c083c64.rlib | Bin 0 -> 204916 bytes .../debug/deps/libitoa-e940bf7c9c083c64.rmeta | Bin 0 -> 60666 bytes .../deps/libmemchr-55c8f9bd116d57f0.rlib | Bin 0 -> 2564844 bytes .../deps/libmemchr-55c8f9bd116d57f0.rmeta | Bin 0 -> 1295946 bytes .../deps/libproc_macro2-6e7a54961830b09e.rlib | Bin 0 -> 1251530 bytes .../libproc_macro2-6e7a54961830b09e.rmeta | Bin 0 -> 343543 bytes .../debug/deps/libquote-f95d225106368b84.rlib | Bin 0 -> 516168 bytes .../deps/libquote-f95d225106368b84.rmeta | Bin 0 -> 270949 bytes .../debug/deps/libserde-4f0323fc6c5c4c08.rlib | Bin 0 -> 1187606 bytes .../deps/libserde-4f0323fc6c5c4c08.rmeta | Bin 0 -> 832159 bytes .../deps/libserde_core-50472241cf64cf59.rlib | Bin 0 -> 5275954 bytes .../deps/libserde_core-50472241cf64cf59.rmeta | Bin 0 -> 4774670 bytes .../deps/libserde_derive-ac77baf888970ea2.so | Bin 0 -> 9316624 bytes .../deps/libserde_json-86f92794bab1b2e3.rlib | Bin 0 -> 5958586 bytes .../deps/libserde_json-86f92794bab1b2e3.rmeta | Bin 0 -> 1719476 bytes .../debug/deps/libsyn-ba824d1fb7fccb81.rlib | Bin 0 -> 6418340 bytes .../debug/deps/libsyn-ba824d1fb7fccb81.rmeta | Bin 0 -> 2231491 bytes .../libunicode_ident-30c770f20c543060.rlib | Bin 0 -> 54918 bytes .../libunicode_ident-30c770f20c543060.rmeta | Bin 0 -> 32903 bytes .../debug/deps/libzmij-dac683281b28ed51.rlib | Bin 0 -> 665826 bytes .../debug/deps/libzmij-dac683281b28ed51.rmeta | Bin 0 -> 419321 bytes .../debug/deps/memchr-55c8f9bd116d57f0.d | 33 ++ .../debug/deps/proc_macro2-6e7a54961830b09e.d | 17 + .../debug/deps/quote-f95d225106368b84.d | 13 + .../debug/deps/serde-4f0323fc6c5c4c08.d | 14 + .../debug/deps/serde_core-50472241cf64cf59.d | 27 ++ .../deps/serde_derive-ac77baf888970ea2.d | 34 ++ .../debug/deps/serde_json-86f92794bab1b2e3.d | 40 ++ .../target/debug/deps/syn-ba824d1fb7fccb81.d | 49 +++ .../deps/unicode_ident-30c770f20c543060.d | 8 + .../target/debug/deps/zmij-dac683281b28ed51.d | 9 + .../dep-graph.bin | Bin 0 -> 2988366 bytes .../epd2h68bcog5vd4j3iqu6akcy.o | Bin 0 -> 79744 bytes .../excl49wgbwmak6o89majtykn2.o | Bin 0 -> 3464 bytes .../metadata.rmeta | Bin 0 -> 615182 bytes .../query-cache.bin | Bin 0 -> 1907994 bytes .../work-products.bin | Bin 0 -> 252 bytes .../s-hlzwd2iw7e-11yfjl3.lock | 0 event-model/target/debug/libevent_model.d | 1 + event-model/target/debug/libevent_model.rlib | Bin 0 -> 707862 bytes server/Cargo.lock | 9 + server/Cargo.toml | 4 + server/src/session/driver.rs | 365 +---------------- server/src/session/transcript.rs | 16 +- 140 files changed, 863 insertions(+), 365 deletions(-) create mode 100644 event-model/Cargo.lock create mode 100644 event-model/Cargo.toml create mode 100644 event-model/src/lib.rs create mode 100644 event-model/target/.rustc_info.json create mode 100644 event-model/target/CACHEDIR.TAG create mode 100644 event-model/target/debug/.cargo-artifact-lock create mode 100644 event-model/target/debug/.cargo-build-lock create mode 100644 event-model/target/debug/.cargo-lock create mode 100644 event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/dep-lib-event_model create mode 100644 event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model create mode 100644 event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model.json create mode 100644 event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/dep-lib-itoa create mode 100644 event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa create mode 100644 event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa.json create mode 100644 event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/dep-lib-memchr create mode 100644 event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr create mode 100644 event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr.json create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/dep-lib-proc_macro2 create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2 create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2.json create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/quote-096835ab63739f47/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/quote-096835ab63739f47/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/quote-f95d225106368b84/dep-lib-quote create mode 100644 event-model/target/debug/.fingerprint/quote-f95d225106368b84/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote create mode 100644 event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote.json create mode 100644 event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/dep-lib-serde create mode 100644 event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde create mode 100644 event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde.json create mode 100644 event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/dep-lib-serde_core create mode 100644 event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core create mode 100644 event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core.json create mode 100644 event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/dep-lib-serde_derive create mode 100644 event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive create mode 100644 event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive.json create mode 100644 event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/dep-lib-serde_json create mode 100644 event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json create mode 100644 event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json.json create mode 100644 event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/dep-lib-syn create mode 100644 event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn create mode 100644 event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn.json create mode 100644 event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/dep-lib-unicode_ident create mode 100644 event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident create mode 100644 event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident.json create mode 100644 event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build.json create mode 100644 event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/dep-build-script-build-script-build create mode 100644 event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/dep-lib-zmij create mode 100644 event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/invoked.timestamp create mode 100644 event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij create mode 100644 event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij.json create mode 100644 event-model/target/debug/deps/event_model-22939ccd17cf0d53.d create mode 100644 event-model/target/debug/deps/itoa-e940bf7c9c083c64.d create mode 100644 event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rlib create mode 100644 event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rmeta create mode 100644 event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rlib create mode 100644 event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rmeta create mode 100644 event-model/target/debug/deps/libmemchr-55c8f9bd116d57f0.rlib create mode 100644 event-model/target/debug/deps/libmemchr-55c8f9bd116d57f0.rmeta create mode 100644 event-model/target/debug/deps/libproc_macro2-6e7a54961830b09e.rlib create mode 100644 event-model/target/debug/deps/libproc_macro2-6e7a54961830b09e.rmeta create mode 100644 event-model/target/debug/deps/libquote-f95d225106368b84.rlib create mode 100644 event-model/target/debug/deps/libquote-f95d225106368b84.rmeta create mode 100644 event-model/target/debug/deps/libserde-4f0323fc6c5c4c08.rlib create mode 100644 event-model/target/debug/deps/libserde-4f0323fc6c5c4c08.rmeta create mode 100644 event-model/target/debug/deps/libserde_core-50472241cf64cf59.rlib create mode 100644 event-model/target/debug/deps/libserde_core-50472241cf64cf59.rmeta create mode 100755 event-model/target/debug/deps/libserde_derive-ac77baf888970ea2.so create mode 100644 event-model/target/debug/deps/libserde_json-86f92794bab1b2e3.rlib create mode 100644 event-model/target/debug/deps/libserde_json-86f92794bab1b2e3.rmeta create mode 100644 event-model/target/debug/deps/libsyn-ba824d1fb7fccb81.rlib create mode 100644 event-model/target/debug/deps/libsyn-ba824d1fb7fccb81.rmeta create mode 100644 event-model/target/debug/deps/libunicode_ident-30c770f20c543060.rlib create mode 100644 event-model/target/debug/deps/libunicode_ident-30c770f20c543060.rmeta create mode 100644 event-model/target/debug/deps/libzmij-dac683281b28ed51.rlib create mode 100644 event-model/target/debug/deps/libzmij-dac683281b28ed51.rmeta create mode 100644 event-model/target/debug/deps/memchr-55c8f9bd116d57f0.d create mode 100644 event-model/target/debug/deps/proc_macro2-6e7a54961830b09e.d create mode 100644 event-model/target/debug/deps/quote-f95d225106368b84.d create mode 100644 event-model/target/debug/deps/serde-4f0323fc6c5c4c08.d create mode 100644 event-model/target/debug/deps/serde_core-50472241cf64cf59.d create mode 100644 event-model/target/debug/deps/serde_derive-ac77baf888970ea2.d create mode 100644 event-model/target/debug/deps/serde_json-86f92794bab1b2e3.d create mode 100644 event-model/target/debug/deps/syn-ba824d1fb7fccb81.d create mode 100644 event-model/target/debug/deps/unicode_ident-30c770f20c543060.d create mode 100644 event-model/target/debug/deps/zmij-dac683281b28ed51.d create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/dep-graph.bin create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/epd2h68bcog5vd4j3iqu6akcy.o create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/excl49wgbwmak6o89majtykn2.o create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/metadata.rmeta create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/query-cache.bin create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3-4vrw7u7swv1osx9ptqb4qu06f/work-products.bin create mode 100644 event-model/target/debug/incremental/event_model-0gqz9314xn63l/s-hlzwd2iw7e-11yfjl3.lock create mode 100644 event-model/target/debug/libevent_model.d create mode 100644 event-model/target/debug/libevent_model.rlib diff --git a/event-model/Cargo.lock b/event-model/Cargo.lock new file mode 100644 index 0000000..1bbc389 --- /dev/null +++ b/event-model/Cargo.lock @@ -0,0 +1,107 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "event-model" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "syn" +version = "3.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/event-model/Cargo.toml b/event-model/Cargo.toml new file mode 100644 index 0000000..00617e5 --- /dev/null +++ b/event-model/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "event-model" +version = "0.1.0" +edition = "2024" + +# The common event model, extracted from `server/session/driver.rs` and +# `session/transcript.rs` so a Rust client (`client-core`) can share one +# definition with the server instead of hand-mirroring it the way +# `app/.../Events.kt` used to. Nothing here talks to a process, a file, or a +# socket -- it is exactly the wire shape in PLAN.md's "common event model", +# plus the transcript envelope and the context-token rule three different +# readers (the pump, the transcript, and a phone folding the same events) +# have to agree on. + +[dependencies] +serde = { version = "1", features = ["derive"] } +# `Event::ToolStart.input` is a tool's raw call arguments, whatever shape the +# dialect gave them -- typing it further would mean this crate knowing every +# driver's tool schema. +serde_json = { version = "1", features = ["float_roundtrip"] } diff --git a/event-model/src/lib.rs b/event-model/src/lib.rs new file mode 100644 index 0000000..9b96ad5 --- /dev/null +++ b/event-model/src/lib.rs @@ -0,0 +1,377 @@ +//! The common event model: what a driver's process turns into before it +//! touches the transcript or the phone (see `PLAN.md`'s "The common event +//! model"). Extracted from `server/src/session/driver.rs` and +//! `session/transcript.rs` on 2026-09-04 so `client-core` shares this +//! definition instead of hand-mirroring it, which is what +//! `app/.../Events.kt` used to do. `server/`'s `session::driver` module +//! re-exports everything here, so nothing downstream of it had to change. +//! +//! What stayed behind in `server/`: the `Driver` trait, `SessionCommand`, +//! `Unqueued` and `EventSink`. Those are how *this* server runs a session, +//! not part of what a client reads off the wire. + +use serde::{Deserialize, Serialize}; + +/// The name a session's image is stored and served under -- minted for an +/// upload or for one a tool produced, and fetched back from +/// `/sessions/{id}/files/{ref}`. One id both directions, so the transcript +/// renders them identically. +pub type ImageRef = String; + +/// The name an upload is stored and served under: an image is +/// `.` and is an [`ImageRef`] like any other; any other file +/// keeps its own name after the hex, `-`, because the name is what +/// the reader attached and what the session is told. Told apart by +/// `crate::media::media_type_for`. +pub type AttachmentRef = String; + +/// One choice offered in answer to a [`Event::Question`]. More than a label +/// because the reader is deciding rather than confirming: what an option +/// means, and what picking it would produce, are what decide it. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct QuestionOption { + pub label: String, + /// A sentence about what this option means. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + /// A block to show as written -- a mockup, a diff, a config file. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub preview: Option, +} + +impl QuestionOption { + pub fn plain(label: impl Into) -> Self { + Self { + label: label.into(), + description: None, + preview: None, + } + } +} + +/// Everything a session can tell the outside world. Every event is appended +/// to the transcript with a sequence number, then fanned out to SSE +/// subscribers, so reconnecting is just "events after seq N" -- no separate +/// history path to drift from the live one. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +// `rename_all` renames the variants; `rename_all_fields` renames what is +// inside them. Both are needed and only the first is obvious: every field +// here was one lowercase word until `pre_tokens` arrived, so a multi-word +// field went out as snake_case, the app looked for camelCase and found +// nothing, and the event still rendered -- as the "no counts reported" case, +// which is a state it is allowed to be in. +#[serde( + tag = "type", + rename_all = "camelCase", + rename_all_fields = "camelCase" +)] +pub enum Event { + /// What the user sent, written into the transcript by the manager (not by + /// drivers) so every device renders the conversation from one stream. + /// Recorded when the session reads it, which is what `MessageTaken` reports. + UserMessage { + /// The [`Event::MessageQueued`] this resolves, when it waited. The + /// phone has a bubble on screen for the waiting message and needs to + /// know *which* one this is, rather than matching on the text and + /// clearing the wrong one when the same thing was sent twice. + #[serde(default, skip_serializing_if = "Option::is_none")] + id: Option, + text: String, + /// What was attached, by the ref the files route serves. On the + /// message rather than beside it: these used to be their own `Image` + /// events just before, which left the phone deciding from adjacency + /// which message an image belonged to. `images` on disk until + /// 2026-09-03, when files joined them; the alias reads the older rows. + #[serde(default, alias = "images", skip_serializing_if = "Vec::is_empty")] + attachments: Vec, + }, + /// A message accepted from the phone that the session cannot read yet. + /// + /// Recorded, unlike the message itself, and that difference is the point: + /// the message belongs in the transcript where the session read it, but + /// something has to say it is waiting, and it has to be the server. The + /// phone used to remember its own outgoing messages, so leaving the + /// screen showed nothing pending when something was. + /// + /// Carries no row of its own; resolved by the `UserMessage` bearing the + /// same id, as `CommandQueued` is resolved by `CommandSent`. + MessageQueued { + id: String, + text: String, + /// Carried for the same reason [`Event::UserMessage`] carries it, + /// and it matters more here: a waiting message is on screen for as + /// long as the turn runs, so its attachment has nowhere else to be. + #[serde(default, alias = "images", skip_serializing_if = "Vec::is_empty")] + attachments: Vec, + }, + /// A message taken out of the queue before the session read it. + /// + /// Recorded for the same reason `MessageQueued` is: the queue is the + /// server's, so what is waiting has to be answerable from the transcript + /// alone. Without it a phone that reconnects replays the `MessageQueued` + /// and puts back a bubble nothing will ever resolve -- the `UserMessage` + /// that normally does is exactly what is not coming. + /// + /// Only ever sent for a message that had not been handed over; see + /// [`Unqueued::AlreadySent`]. + MessageDropped { + id: String, + }, + /// A driver has taken one of the user's messages and started reading it. + /// The manager turns this into the `UserMessage` above, so it never + /// reaches a phone itself. + /// + /// It exists because sending and being read are not the same moment. A + /// message sent into a running turn waits, and recording it among things + /// already read puts it in the transcript above output that predates it. + MessageTaken { + /// The `MessageQueued` this answers, or `None` when it never waited. + /// Carried through onto the `UserMessage`. + id: Option, + text: String, + #[serde(default, alias = "images", skip_serializing_if = "Vec::is_empty")] + attachments: Vec, + }, + /// Streaming assistant text; the phone renders the concatenation as + /// markdown. + AssistantText { + delta: String, + }, + ToolStart { + id: String, + tool: String, + input: serde_json::Value, + }, + ToolUpdate { + id: String, + output: String, + }, + ToolEnd { + id: String, + output: String, + }, + /// An image the session produced or was sent, saved under the session + /// dir and referenced by id; the phone fetches it by URL. + Image { + #[serde(rename = "ref")] + image: ImageRef, + /// The tool call whose result carried it, when one did. A screenshot + /// belongs under the call that took it, not floating beside it -- the + /// reader has to pair them by position otherwise, and position is + /// exactly what a page boundary breaks. + #[serde(default, skip_serializing_if = "Option::is_none")] + about: Option, + }, + /// Anything the session needs a human for: AskUserQuestion, and + /// permission requests, are the same shape with different options. + Question { + id: String, + prompt: String, + /// A few words naming what the question is about, when the asker + /// offered one. `None` for a permission, which is about the call + /// above it. + header: Option, + options: Vec, + /// Whether several options may be chosen at once. Here rather than + /// left for a phone to work out from the dialect underneath: how many + /// answers a question takes is a fact about the question, and the + /// alternative was Claude Code's tool-input schema written out a + /// second time in Kotlin, where no other dialect could reach it. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + multi_select: bool, + /// The tool call this is permission for, when it is one, so a phone + /// can draw the ask on the tool's own row rather than as a second + /// card repeating its input. `None` for anything not about a tool. + #[serde(default, skip_serializing_if = "Option::is_none")] + about: Option, + }, + /// A message another agent sent this session. + /// + /// Its own kind rather than a `UserMessage`, because it is not something + /// the reader said and a transcript that renders it in their voice is + /// claiming they did. It also explains what would otherwise be + /// inexplicable: a session working on something nobody here asked for. + PeerMessage { + /// The sending session's own name, which is what the reader + /// recognises it by -- the socket path it came from is not. + from: String, + text: String, + /// The seq of the `Status::Running` that opened the turn this message + /// started, so a reader can draw it above that turn. + /// + /// The CLI says nothing about a peer message until the turn's + /// `result`, so the event is appended after everything it caused, and + /// an append-only transcript cannot go back and insert it. Carrying + /// the position instead keeps one order on the wire and one on screen. + /// + /// Filled in by the pump, the only place that knows a seq, and only + /// where a turn was open: `None` for a message replayed by `import`, + /// which already has it in the right place. + #[serde(default, skip_serializing_if = "Option::is_none")] + turn_start: Option, + }, + /// The manager's record of a question being answered, so a rendered + /// question card resolves on every device rather than only the one that + /// answered. + /// + /// A list because a question can take several answers, and one that took + /// one is the list of length one rather than a different shape. + Answered { + id: String, + answers: Vec, + }, + Status { + state: SessionStatus, + }, + /// What the session is set to, as the session itself reports it. + /// + /// Asking for a change and having one are different things, and only this + /// is a measurement: a model name the dialect does not know, a mode it + /// refuses, or a driver whose model is fixed at startup all leave a + /// request that was sent and nothing that changed. Reporting from the + /// request put the answer on the phone before the question was answered. + /// + /// Either field alone, because the two are confirmed separately. + Settings { + #[serde(default, skip_serializing_if = "Option::is_none")] + model: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + permission_mode: Option, + }, + /// Per-turn token counts, where the dialect reports them. + UsageDelta { + /// What this turn cost: the tokens it was charged for. + tokens: u64, + /// What the model was holding when the turn ended -- see + /// [`context_tokens`]. + /// + /// Carried rather than summed by whoever is reading, because it is + /// not a sum: context goes *down* at a compaction and a clear, so + /// adding turns up would report a figure the session stopped being + /// true of long ago. + /// + /// `None` where the dialect did not say, which every reader has to be + /// able to draw. + #[serde(default, skip_serializing_if = "Option::is_none")] + context: Option, + }, + /// A compaction that finished, and how much context it recovered. + /// + /// The counts are the point, and a spinner is not. They are optional + /// because the record has shipped without them, and "the compaction + /// happened, we don't know by how much" is a state this has to be able to + /// say -- a plausible number would be indistinguishable from a counted one. + Compacted { + #[serde(default, skip_serializing_if = "Option::is_none")] + pre_tokens: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + post_tokens: Option, + /// What asked for it, in the dialect's own word -- `auto` when the + /// session compacted on its own. Carried rather than reduced to a bool + /// so an unrecognised trigger stays unrecognised: an automatic + /// compaction is the one worth naming, because it explains a wait + /// nobody asked for. + #[serde(default, skip_serializing_if = "Option::is_none")] + trigger: Option, + }, + /// A command the session was asked to run on itself, held because it + /// cannot run yet. These are not messages: `/compact` and `/rename` are + /// instructions about the session, and a session mid-turn reads a line + /// written to it as something the model should see. So they wait, and + /// this is what a phone draws while they do. + CommandQueued { + id: String, + text: String, + }, + /// The same command, now handed to the session. Its [`CommandQueued`] + /// stops being pending when this arrives, matched by `id`; a command + /// that ran immediately has only this. + CommandSent { + id: String, + text: String, + }, + /// The conversation was cleared: everything above this is still in the + /// record but is no longer in the session's context. + /// + /// Nothing is deleted. A transcript is the thing a person scrolls back + /// through, so this is a divider, not a truncation. + /// + /// **Load-bearing, not decorative.** For any driver that rebuilds its + /// conversation from the transcript, this marker decides what the model + /// is given -- dropping it, or treating it as something only the phone + /// draws, silently puts a cleared conversation back in front of the model + /// at full cost. Today `llama::conversation` is the only fold that reads + /// it, which is why this is written down rather than left to be inferred + /// from a second example that does not exist. + Cleared, + Error { + message: String, + }, +} + +/// How much the model was holding, from the three figures a turn reports: +/// the input side only, prompt plus both cache figures. A cached token is +/// cheaper but it is still one the model was given; output is what the turn +/// produced rather than what continuing has to carry. +/// +/// One function so the definition cannot drift, because it is extracted two +/// quite different ways -- the live translators have the usage object parsed, +/// and `import::context_tokens` scans it out of a raw line without parsing. +pub fn context_tokens(input: u64, cache_creation: u64, cache_read: u64) -> u64 { + input + cache_creation + cache_read +} + +/// The context after `event`, given what it was before. +/// +/// The whole rule in one place, because three readers need the same answer: +/// the pump keeping a live session's figure, the transcript seeding it at +/// startup, and the phone folding the same events into what it draws. +/// +/// The two that *lower* it are the point. A clear takes the conversation away +/// and a compaction replaces it with a summary, so a figure measured before +/// either stopped being true at that moment -- and carrying it forward is how +/// a session that had just been cleared went on reporting the context it no +/// longer had. +/// +/// `None` is "we don't know", which each of them can reach. +pub fn context_after(current: Option, event: &Event) -> Option { + match event { + // `or`, so a turn the dialect reported no usage for leaves the last + // measurement standing: stale by a turn, which every context figure + // is, rather than wrong. + Event::UsageDelta { context, .. } => context.or(current), + Event::Compacted { post_tokens, .. } => *post_tokens, + Event::Cleared => None, + _ => current, + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum SessionStatus { + Idle, + Running, + AwaitingInput, + Compacting, + Exited, + /// There is a process recorded for this session and the machine will not + /// say whether it is still running. + /// + /// Its own state rather than the nearest of the others, because both + /// neighbours are lies with consequences: `Exited` invites starting a + /// second process against a conversation that may already have one, and + /// `Idle` claims a session is waiting for you when nobody has checked. + Unknown, +} + +/// One transcript line: an [`Event`] plus its position and time. The event +/// is flattened so the wire shape stays one flat object. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct SeqEvent { + pub seq: u64, + /// Epoch seconds. + pub ts: f64, + #[serde(flatten)] + pub event: Event, +} diff --git a/event-model/target/.rustc_info.json b/event-model/target/.rustc_info.json new file mode 100644 index 0000000..0f29bf6 --- /dev/null +++ b/event-model/target/.rustc_info.json @@ -0,0 +1 @@ +{"rustc_fingerprint":16968256872041900714,"outputs":{"8688260251109005551":{"success":true,"status":"","code":0,"stdout":"rustc 1.98.0 (88d9e12ae 2026-08-18)\nbinary: rustc\ncommit-hash: 88d9e12ae178fab0fb5cc050a94da85685d449ea\ncommit-date: 2026-08-18\nhost: x86_64-unknown-linux-gnu\nrelease: 1.98.0\nLLVM version: 22.1.8\n","stderr":""},"7971740275564407648":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/bob/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_primitive_alignment=\"16\"\ntarget_has_atomic_primitive_alignment=\"32\"\ntarget_has_atomic_primitive_alignment=\"64\"\ntarget_has_atomic_primitive_alignment=\"8\"\ntarget_has_atomic_primitive_alignment=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}} \ No newline at end of file diff --git a/event-model/target/CACHEDIR.TAG b/event-model/target/CACHEDIR.TAG new file mode 100644 index 0000000..20d7c31 --- /dev/null +++ b/event-model/target/CACHEDIR.TAG @@ -0,0 +1,3 @@ +Signature: 8a477f597d28d172789f06886806bc55 +# This file is a cache directory tag created by cargo. +# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/event-model/target/debug/.cargo-artifact-lock b/event-model/target/debug/.cargo-artifact-lock new file mode 100644 index 0000000..e69de29 diff --git a/event-model/target/debug/.cargo-build-lock b/event-model/target/debug/.cargo-build-lock new file mode 100644 index 0000000..e69de29 diff --git a/event-model/target/debug/.cargo-lock b/event-model/target/debug/.cargo-lock new file mode 100644 index 0000000..e69de29 diff --git a/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/dep-lib-event_model b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/dep-lib-event_model new file mode 100644 index 0000000000000000000000000000000000000000..024be4904569dbe2c19582a923171096f5c21ee4 GIT binary patch literal 30 gcmZQ%U|{&q$Ot4ExPZ90C|N%zGfA(g7$m{~07A6{&Hw-a literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/invoked.timestamp b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model new file mode 100644 index 0000000..7b5fae4 --- /dev/null +++ b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model @@ -0,0 +1 @@ +0a35a2159733b34f \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model.json b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model.json new file mode 100644 index 0000000..9e170b3 --- /dev/null +++ b/event-model/target/debug/.fingerprint/event-model-22939ccd17cf0d53/lib-event_model.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[]","declared_features":"[]","target":7600547062124258715,"profile":8731458305071235362,"path":10763286916239946207,"deps":[[5330460842384404171,"serde_json",false,3521654318384187666],[6557439603276904804,"serde",false,9115200261241786175]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/event-model-22939ccd17cf0d53/dep-lib-event_model","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/dep-lib-itoa b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/dep-lib-itoa new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/invoked.timestamp b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa new file mode 100644 index 0000000..73ba3ea --- /dev/null +++ b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa @@ -0,0 +1 @@ +28d1a47e1679c2ee \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa.json b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa.json new file mode 100644 index 0000000..3221dd2 --- /dev/null +++ b/event-model/target/debug/.fingerprint/itoa-e940bf7c9c083c64/lib-itoa.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[]","declared_features":"[\"no-panic\"]","target":18426369533666673425,"profile":15657897354478470176,"path":14942821222029544552,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/itoa-e940bf7c9c083c64/dep-lib-itoa","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/dep-lib-memchr b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/dep-lib-memchr new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/invoked.timestamp b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr new file mode 100644 index 0000000..467ea46 --- /dev/null +++ b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr @@ -0,0 +1 @@ +e07eefd3ad107c74 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr.json b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr.json new file mode 100644 index 0000000..f1f795f --- /dev/null +++ b/event-model/target/debug/.fingerprint/memchr-55c8f9bd116d57f0/lib-memchr.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"alloc\", \"std\"]","declared_features":"[\"alloc\", \"core\", \"default\", \"libc\", \"logging\", \"rustc-dep-of-std\", \"std\", \"use_std\"]","target":11745930252914242013,"profile":15657897354478470176,"path":17502693890317708870,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/memchr-55c8f9bd116d57f0/dep-lib-memchr","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/dep-lib-proc_macro2 b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/dep-lib-proc_macro2 new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/invoked.timestamp b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2 b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2 new file mode 100644 index 0000000..8b03abd --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2 @@ -0,0 +1 @@ +908122be755d3bde \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2.json b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2.json new file mode 100644 index 0000000..c230c6e --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-6e7a54961830b09e/lib-proc_macro2.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"proc-macro\"]","declared_features":"[\"default\", \"nightly\", \"proc-macro\", \"span-locations\"]","target":369203346396300798,"profile":2225463790103693989,"path":9326605962526047067,"deps":[[8901712065508858692,"unicode_ident",false,9002592617963285065],[16346726298725429545,"build_script_build",false,10309388049098035721]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/proc-macro2-6e7a54961830b09e/dep-lib-proc_macro2","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build new file mode 100644 index 0000000..45bddcf --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build @@ -0,0 +1 @@ +ebf2d64d567abd7a \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build.json new file mode 100644 index 0000000..0a24bea --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"proc-macro\"]","declared_features":"[\"default\", \"nightly\", \"proc-macro\", \"span-locations\"]","target":5408242616063297496,"profile":2225463790103693989,"path":9923770499906903100,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/proc-macro2-ced09248f21b5d01/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/invoked.timestamp b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-ced09248f21b5d01/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build new file mode 100644 index 0000000..65639fe --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build @@ -0,0 +1 @@ +09522526cf4d128f \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build.json new file mode 100644 index 0000000..094bc17 --- /dev/null +++ b/event-model/target/debug/.fingerprint/proc-macro2-e91ee3baef79ebaa/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[16346726298725429545,"build_script_build",false,8844359754317230827]],"local":[{"RerunIfChanged":{"output":"debug/build/proc-macro2-e91ee3baef79ebaa/output","paths":["src/probe/proc_macro_span.rs","src/probe/proc_macro_span_location.rs","src/probe/proc_macro_span_file.rs"]}},{"RerunIfEnvChanged":{"var":"RUSTC_BOOTSTRAP","val":null}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build new file mode 100644 index 0000000..73a90c5 --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build @@ -0,0 +1 @@ +955e16406e5ac1b6 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build.json new file mode 100644 index 0000000..e8dfb49 --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"proc-macro\"]","declared_features":"[\"default\", \"proc-macro\"]","target":5408242616063297496,"profile":2225463790103693989,"path":15204616833879173795,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/quote-096835ab63739f47/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-096835ab63739f47/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/quote-096835ab63739f47/invoked.timestamp b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-096835ab63739f47/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build new file mode 100644 index 0000000..9ad8b8f --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build @@ -0,0 +1 @@ +1ae8d1ff6de00712 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build.json new file mode 100644 index 0000000..d3fe40c --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-a65b75d92ce755e8/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[8949245912927223590,"build_script_build",false,13168906214976151189]],"local":[{"RerunIfChanged":{"output":"debug/build/quote-a65b75d92ce755e8/output","paths":["build.rs"]}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-f95d225106368b84/dep-lib-quote b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/dep-lib-quote new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/quote-f95d225106368b84/invoked.timestamp b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote new file mode 100644 index 0000000..e0de68c --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote @@ -0,0 +1 @@ +ec92212b256d4034 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote.json b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote.json new file mode 100644 index 0000000..8ec3542 --- /dev/null +++ b/event-model/target/debug/.fingerprint/quote-f95d225106368b84/lib-quote.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"proc-macro\"]","declared_features":"[\"default\", \"proc-macro\"]","target":8313845041260779044,"profile":2225463790103693989,"path":10909413009652471663,"deps":[[8949245912927223590,"build_script_build",false,1299253780567681050],[16346726298725429545,"proc_macro2",false,16013495660328419728]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/quote-f95d225106368b84/dep-lib-quote","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build new file mode 100644 index 0000000..1a7c878 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build @@ -0,0 +1 @@ +866e564a9d5b80a7 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build.json new file mode 100644 index 0000000..e34e6ea --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-2b6dc38641ca5f93/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[6557439603276904804,"build_script_build",false,7538447504461486726]],"local":[{"RerunIfChanged":{"output":"debug/build/serde-2b6dc38641ca5f93/output","paths":["build.rs"]}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/dep-lib-serde b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/dep-lib-serde new file mode 100644 index 0000000000000000000000000000000000000000..406cafda9fac3d0ecb03693f99ed8520a8009c63 GIT binary patch literal 69 zcmZQ%U|{&q$Ot4E4S_^TYEo&seo|>>PKthUYEeq6u2GU%O0uzqnTcU?qG_6?v3`DO UiGD#*W?5oMs$NksP!9tG07o(s5C8xG literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/invoked.timestamp b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde new file mode 100644 index 0000000..4b60165 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde @@ -0,0 +1 @@ +3f4fdddb57b27f7e \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde.json b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde.json new file mode 100644 index 0000000..3fb66c3 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-4f0323fc6c5c4c08/lib-serde.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"default\", \"derive\", \"serde_derive\", \"std\"]","declared_features":"[\"alloc\", \"default\", \"derive\", \"rc\", \"serde_derive\", \"std\", \"unstable\"]","target":11327258112168116673,"profile":15657897354478470176,"path":259703313627472752,"deps":[[6557439603276904804,"build_script_build",false,12069747732468100742],[11029742160753049355,"serde_core",false,10682519779281431540],[13312204359551525516,"serde_derive",false,12133960540131049856]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde-4f0323fc6c5c4c08/dep-lib-serde","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build new file mode 100644 index 0000000..5e47a5f --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build @@ -0,0 +1 @@ +865a5b9d10f29d68 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build.json new file mode 100644 index 0000000..60e0dc7 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"default\", \"derive\", \"serde_derive\", \"std\"]","declared_features":"[\"alloc\", \"default\", \"derive\", \"rc\", \"serde_derive\", \"std\", \"unstable\"]","target":5408242616063297496,"profile":2225463790103693989,"path":12674769013409038814,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde-f06f4da0f75e7ba8/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/invoked.timestamp b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde-f06f4da0f75e7ba8/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build new file mode 100644 index 0000000..aba6cca --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build @@ -0,0 +1 @@ +11153b22c3aaf488 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build.json new file mode 100644 index 0000000..dc5d295 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"result\", \"std\"]","declared_features":"[\"alloc\", \"default\", \"rc\", \"result\", \"std\", \"unstable\"]","target":5408242616063297496,"profile":2225463790103693989,"path":3109787618151281189,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde_core-0a31bdcb556041d4/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/invoked.timestamp b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-0a31bdcb556041d4/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/dep-lib-serde_core b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/dep-lib-serde_core new file mode 100644 index 0000000000000000000000000000000000000000..8870428e371de70828478f5b4e361c2649914dd8 GIT binary patch literal 74 zcmWN|Q3`+{5Cy>91Jx>M(P<*}AwpoR+V#ty`5Pvpk9o@5Bq59}VU#;bgC?A@DwgQ& XZfr1zb8zrR>ge)ld9RLD+l)j%v)&W3 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/invoked.timestamp b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core new file mode 100644 index 0000000..9b1ac26 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core @@ -0,0 +1 @@ +f46b270e24ef3f94 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core.json b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core.json new file mode 100644 index 0000000..f490e6d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-50472241cf64cf59/lib-serde_core.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"result\", \"std\"]","declared_features":"[\"alloc\", \"default\", \"rc\", \"result\", \"std\", \"unstable\"]","target":6810695588070812737,"profile":15657897354478470176,"path":17604523466576488115,"deps":[[11029742160753049355,"build_script_build",false,11881783826505965304]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde_core-50472241cf64cf59/dep-lib-serde_core","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build new file mode 100644 index 0000000..7188d13 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build @@ -0,0 +1 @@ +f89ede147093e4a4 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build.json new file mode 100644 index 0000000..323624b --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_core-c51701b0944e4e50/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[11029742160753049355,"build_script_build",false,9868700438545241361]],"local":[{"RerunIfChanged":{"output":"debug/build/serde_core-c51701b0944e4e50/output","paths":["build.rs"]}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/dep-lib-serde_derive b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/dep-lib-serde_derive new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/invoked.timestamp b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive new file mode 100644 index 0000000..b8412c4 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive @@ -0,0 +1 @@ +80411ea1d27c64a8 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive.json b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive.json new file mode 100644 index 0000000..2561698 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_derive-ac77baf888970ea2/lib-serde_derive.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"default\"]","declared_features":"[\"default\", \"deserialize_in_place\"]","target":13076129734743110817,"profile":2225463790103693989,"path":1622169132691883934,"deps":[[4481353994425695856,"syn",false,3884405872263008629],[8949245912927223590,"quote",false,3765129294886572780],[16346726298725429545,"proc_macro2",false,16013495660328419728]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde_derive-ac77baf888970ea2/dep-lib-serde_derive","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/dep-lib-serde_json b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/dep-lib-serde_json new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/invoked.timestamp b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json new file mode 100644 index 0000000..b5a619f --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json @@ -0,0 +1 @@ +128902adf16ddf30 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json.json b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json.json new file mode 100644 index 0000000..7eee32f --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-86f92794bab1b2e3/lib-serde_json.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"default\", \"float_roundtrip\", \"std\"]","declared_features":"[\"alloc\", \"arbitrary_precision\", \"default\", \"float_roundtrip\", \"indexmap\", \"preserve_order\", \"raw_value\", \"std\", \"unbounded_depth\"]","target":9592559880233824070,"profile":15657897354478470176,"path":18434498419618500693,"deps":[[5330460842384404171,"build_script_build",false,7131227597519702231],[5532778797167691009,"itoa",false,17204446664029688104],[11029742160753049355,"serde_core",false,10682519779281431540],[12613788554453945248,"memchr",false,8393602144282836704],[16226529040278277557,"zmij",false,11886773985880792019]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde_json-86f92794bab1b2e3/dep-lib-serde_json","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build new file mode 100644 index 0000000..b67602b --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build @@ -0,0 +1 @@ +6c1209b4e144a5c7 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build.json new file mode 100644 index 0000000..b06e369 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"default\", \"float_roundtrip\", \"std\"]","declared_features":"[\"alloc\", \"arbitrary_precision\", \"default\", \"float_roundtrip\", \"indexmap\", \"preserve_order\", \"raw_value\", \"std\", \"unbounded_depth\"]","target":5408242616063297496,"profile":2225463790103693989,"path":6089029597847711871,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/serde_json-9eba6b6192117dbe/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/invoked.timestamp b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-9eba6b6192117dbe/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build new file mode 100644 index 0000000..2dd51c6 --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build @@ -0,0 +1 @@ +d7c89f92b735f762 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build.json new file mode 100644 index 0000000..a35161f --- /dev/null +++ b/event-model/target/debug/.fingerprint/serde_json-b93d1fe6f70f6d93/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[5330460842384404171,"build_script_build",false,14385980320883741292]],"local":[{"RerunIfChanged":{"output":"debug/build/serde_json-b93d1fe6f70f6d93/output","paths":["build.rs"]}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/dep-lib-syn b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/dep-lib-syn new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/invoked.timestamp b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn new file mode 100644 index 0000000..6df1b0c --- /dev/null +++ b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn @@ -0,0 +1 @@ +7591ad738f2ee835 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn.json b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn.json new file mode 100644 index 0000000..e7fcb6b --- /dev/null +++ b/event-model/target/debug/.fingerprint/syn-ba824d1fb7fccb81/lib-syn.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[\"clone-impls\", \"derive\", \"parsing\", \"printing\", \"proc-macro\"]","declared_features":"[\"clone-impls\", \"default\", \"derive\", \"extra-traits\", \"fold\", \"full\", \"parsing\", \"printing\", \"proc-macro\", \"test\", \"visit\", \"visit-mut\"]","target":9442126953582868550,"profile":2225463790103693989,"path":4661929566105643723,"deps":[[8901712065508858692,"unicode_ident",false,9002592617963285065],[8949245912927223590,"quote",false,3765129294886572780],[16346726298725429545,"proc_macro2",false,16013495660328419728]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/syn-ba824d1fb7fccb81/dep-lib-syn","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/dep-lib-unicode_ident b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/dep-lib-unicode_ident new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/invoked.timestamp b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident new file mode 100644 index 0000000..73ea3cf --- /dev/null +++ b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident @@ -0,0 +1 @@ +496a41cb49a2ef7c \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident.json b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident.json new file mode 100644 index 0000000..4dd588c --- /dev/null +++ b/event-model/target/debug/.fingerprint/unicode-ident-30c770f20c543060/lib-unicode_ident.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[]","declared_features":"[]","target":14045917370260632744,"profile":2225463790103693989,"path":10448178182353594507,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/unicode-ident-30c770f20c543060/dep-lib-unicode_ident","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build b/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build new file mode 100644 index 0000000..6b1d36e --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build @@ -0,0 +1 @@ +e9c21c9094bb5e98 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build.json b/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build.json new file mode 100644 index 0000000..6b33dc5 --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-24daae732fd830da/run-build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[16226529040278277557,"build_script_build",false,3183603099212200132]],"local":[{"RerunIfChanged":{"output":"debug/build/zmij-24daae732fd830da/output","paths":["build.rs"]}}],"rustflags":[],"config":0,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build new file mode 100644 index 0000000..9296107 --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build @@ -0,0 +1 @@ +c43860ba266e2e2c \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build.json b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build.json new file mode 100644 index 0000000..47c1e87 --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/build-script-build-script-build.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[]","declared_features":"[\"no-panic\"]","target":5408242616063297496,"profile":2225463790103693989,"path":2094852904543046020,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/zmij-b8e41156ec2eb9b9/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/dep-build-script-build-script-build b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/dep-build-script-build-script-build new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/invoked.timestamp b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-b8e41156ec2eb9b9/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/dep-lib-zmij b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/dep-lib-zmij new file mode 100644 index 0000000000000000000000000000000000000000..ec3cb8bfd28046e47ad4528d5b57859bc05b62f2 GIT binary patch literal 14 QcmZQ%U|{&q2qeG&016uc0ssI2 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/invoked.timestamp b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/invoked.timestamp new file mode 100644 index 0000000..e00328d --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/invoked.timestamp @@ -0,0 +1 @@ +This file has an mtime of when this was started. \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij new file mode 100644 index 0000000..74ae9c0 --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij @@ -0,0 +1 @@ +d35bc719f64df6a4 \ No newline at end of file diff --git a/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij.json b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij.json new file mode 100644 index 0000000..5bc5a8a --- /dev/null +++ b/event-model/target/debug/.fingerprint/zmij-dac683281b28ed51/lib-zmij.json @@ -0,0 +1 @@ +{"rustc":2467252760697041086,"features":"[]","declared_features":"[\"no-panic\"]","target":16603507647234574737,"profile":15657897354478470176,"path":5968495413377776620,"deps":[[16226529040278277557,"build_script_build",false,10979419188323205865]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/zmij-dac683281b28ed51/dep-lib-zmij","checksum":false}}],"rustflags":[],"config":9396254390672932401,"compile_kind":0} \ No newline at end of file diff --git a/event-model/target/debug/deps/event_model-22939ccd17cf0d53.d b/event-model/target/debug/deps/event_model-22939ccd17cf0d53.d new file mode 100644 index 0000000..e42015e --- /dev/null +++ b/event-model/target/debug/deps/event_model-22939ccd17cf0d53.d @@ -0,0 +1,7 @@ +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/event_model-22939ccd17cf0d53.d: src/lib.rs + +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rlib: src/lib.rs + +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rmeta: src/lib.rs + +src/lib.rs: diff --git a/event-model/target/debug/deps/itoa-e940bf7c9c083c64.d b/event-model/target/debug/deps/itoa-e940bf7c9c083c64.d new file mode 100644 index 0000000..c4459e1 --- /dev/null +++ b/event-model/target/debug/deps/itoa-e940bf7c9c083c64.d @@ -0,0 +1,8 @@ +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/itoa-e940bf7c9c083c64.d: /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/lib.rs /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/u128_ext.rs + +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rlib: /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/lib.rs /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/u128_ext.rs + +/home/bob/repos/ai-app-2/.claude/worktrees/agent-a30feda38122e4492/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rmeta: /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/lib.rs /home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/u128_ext.rs + +/home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/lib.rs: +/home/bob/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.18/src/u128_ext.rs: diff --git a/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rlib b/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rlib new file mode 100644 index 0000000000000000000000000000000000000000..bd9c54d4efa2f45e21907aa797a68330af6b9954 GIT binary patch literal 707862 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%0Ag;mSx^d1aBJm_r-n5l{D($x^J6> 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 ZTZ;AVd?1IaQ^T%o7yb1@t*-0%{~r+^(z5^n literal 0 HcmV?d00001 diff --git a/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rmeta b/event-model/target/debug/deps/libevent_model-22939ccd17cf0d53.rmeta new file mode 100644 index 0000000000000000000000000000000000000000..86aa000500cf627f8df293cfc069ca1bc3b73c3c GIT binary patch literal 615182 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

;zTe_}gp(iGy*?v>j)0ZeuGdhNs9%IC&dP>hF1 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%0A<+G_qLBq^5f|nUyv5 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 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rlib b/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rlib new file mode 100644 index 0000000000000000000000000000000000000000..8d67958c5b9f6cc508d7db92f3e5833d344af98d GIT binary patch literal 204916 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 LXKQ!R%hvyYL>IHD literal 0 HcmV?d00001 diff --git a/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rmeta b/event-model/target/debug/deps/libitoa-e940bf7c9c083c64.rmeta new file mode 100644 index 0000000000000000000000000000000000000000..d6e841f5a0a0e727cb0aa0ce132e7694cc041abc GIT binary patch literal 60666 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

A2`Bcx!^(T9j<{sZw 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 literal 0 HcmV?d00001 diff --git a/event-model/target/debug/deps/libmemchr-55c8f9bd116d57f0.rlib b/event-model/target/debug/deps/libmemchr-55c8f9bd116d57f0.rlib new file mode 100644 index 0000000000000000000000000000000000000000..7bde402f4cd6c061bb08e142c2d4692a5a24edbd GIT binary patch literal 2564844 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∨I;hif@p-?VrntZOVAFyfXeTyi6G%?J}vn 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%0Aaw!sYJbgf^O8X)KGI&y9#>{j@mNlQ6Ar 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�qO?8SGoa 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%0AZenkK%A+nxVg)?Moj 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

M$jsb>fK?n|esJKT(XJNI3Z`5Lo?NbH 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�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

P%5Q!71;rQk8_CbfIp%;;1x;?|4SD;V6pZs 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�_6~>Gs0OSMV`;&--tmP{iE4e)P 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 wTejUy=#=Mjqy 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