mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-21 20:28:51 +00:00
plugins-w6: net change of 1 commits
- plugins-w6: written by an agent
This commit is contained in:
@@ -5,15 +5,35 @@
|
||||
//! The window folds the blank that the document's shown fold lines make, about its largest panel
|
||||
//! or the panel the user double-clicked. Its print is a raster of the document with the fold lines
|
||||
//! and the layers that do not print left out ([`vectorcraft_engine::cmd::print_hidden`]), rendered
|
||||
//! once per document revision, off the UI thread on native builds ([`crate::thumb_worker`]), and
|
||||
//! sampled through each panel's projective map when the fold, the view or the print changes. Dragging turns the view, a Shift-drag
|
||||
//! once per document revision on the host's job queue, and sampled through each panel's projective
|
||||
//! map when the fold, the view or the print changes. Dragging turns the view, a Shift-drag
|
||||
//! keeps to one axis, a middle-drag or a Space-drag moves it, the wheel zooms, a double-click on a
|
||||
//! panel makes it the base, and the arrow keys turn the view by 5° when it has the keyboard focus.
|
||||
//! The settings live in `UiState::fold_preview` (`ui.inspect`); `ui.foldPreview` sets them.
|
||||
|
||||
use std::ops::RangeInclusive;
|
||||
use std::sync::Arc;
|
||||
|
||||
use egui::{Color32, Rect, Sense, Ui, vec2};
|
||||
use craft::behavior::{Metrics, NavMove, PointerButton, PressPhase, Sense};
|
||||
use craft::egui::{ColorImage, Key, Pos2, Rect, Response, Ui, Vec2, pos2};
|
||||
use craft::host::queue::{JobQueue, Priority, QueueOptions};
|
||||
use craft::host::{Wake, default_jobs};
|
||||
use craft::ui::buttons::Button;
|
||||
use craft::ui::choice::Checkbox;
|
||||
use craft::ui::contract::{
|
||||
Bind, Common, Component, Cx, Entry, Focus as _, Input, MeasureCx, NoValue, Outcome, PaintUi, Pointer as _, Props as _, Role, Show as _,
|
||||
ShowContainer as _, Sizing, WordSetCx as _,
|
||||
};
|
||||
use craft::ui::display::{Shade, Text};
|
||||
use craft::ui::form::{SliderField, SliderFieldLayout};
|
||||
use craft::ui::layout_components::{Row, Stack};
|
||||
use craft::ui::pickers::Select;
|
||||
use craft::ui::primitives::{Revision, TextureStore, TextureStoreOptions};
|
||||
use craft::ui::runtime::env::{Env, Label, UnitKind};
|
||||
use craft::ui::runtime::focus::{ActivateKeys, KeepKeys, KeyUse};
|
||||
use craft::ui::runtime::keys;
|
||||
use craft::ui::style::{ComponentStyle, FocusLook, StyleCx, SurfaceKind};
|
||||
use craft::ui::value_drag::SliderScale;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_geom::{Point, Rect as DRect};
|
||||
@@ -21,8 +41,7 @@ use vectorcraft_three_d::fold::raster::{self, Camera, Image, MAX_PIXELS, MAX_SID
|
||||
use vectorcraft_three_d::fold::{Blank, Folded, fold, pick};
|
||||
|
||||
use crate::VectorcraftApp;
|
||||
use crate::thumb_worker::{Settle, ThumbWorker};
|
||||
use crate::widgets::{self, dim_label};
|
||||
use crate::thumb_worker::Settle;
|
||||
|
||||
/// The window's id (`window.panel {panel: "foldPreview"}`).
|
||||
pub const ID: &str = "foldPreview";
|
||||
@@ -48,6 +67,46 @@ const PRINT_SIDE: f64 = 2048.0;
|
||||
/// Degrees the view turns for each point dragged, and for each arrow key press.
|
||||
const DRAG_TURN: f64 = 0.5;
|
||||
const KEY_TURN: f64 = 5.0;
|
||||
/// The texture store the drawn image lives in, and its one key.
|
||||
const STORE: &str = "fold-preview";
|
||||
|
||||
craft::ui::words! {
|
||||
/// The words of the Fold Preview window.
|
||||
pub struct FoldPreviewWords {
|
||||
image: "foldPreview.image" = "Fold Preview";
|
||||
view: "foldPreview.view" = "View";
|
||||
inside: "foldPreview.inside" = "Inside";
|
||||
white: "foldPreview.white" = "White";
|
||||
show_fold_lines: "foldPreview.showFoldLines" = "Show Fold Lines";
|
||||
reset: "foldPreview.reset" = "Reset";
|
||||
perspective: "foldPreview.perspective" = "Perspective";
|
||||
fold: "foldPreview.fold" = "Fold";
|
||||
zoom: "foldPreview.zoom" = "Zoom";
|
||||
front: "foldPreview.front" = "Front";
|
||||
back: "foldPreview.back" = "Back";
|
||||
left: "foldPreview.left" = "Left";
|
||||
right: "foldPreview.right" = "Right";
|
||||
top: "foldPreview.top" = "Top";
|
||||
bottom: "foldPreview.bottom" = "Bottom";
|
||||
three_quarter: "foldPreview.threeQuarter" = "Three-Quarter";
|
||||
}
|
||||
}
|
||||
|
||||
impl FoldPreviewWords {
|
||||
/// The name of the view preset `id` (see [`VIEWS`]).
|
||||
fn view_label(&self, id: &str) -> Label {
|
||||
let word = match id {
|
||||
"front" => &self.front,
|
||||
"back" => &self.back,
|
||||
"left" => &self.left,
|
||||
"right" => &self.right,
|
||||
"top" => &self.top,
|
||||
"bottom" => &self.bottom,
|
||||
_ => &self.three_quarter,
|
||||
};
|
||||
Label::from(word.clone())
|
||||
}
|
||||
}
|
||||
|
||||
/// The window's settings (kept with the UI state).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
@@ -119,7 +178,7 @@ fn wrapped(angle: f64) -> f64 {
|
||||
|
||||
/// What the print raster shows: the document, its revision, whether the fold lines are drawn, and
|
||||
/// the region and size.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
struct PrintKey {
|
||||
uid: u64,
|
||||
revision: u64,
|
||||
@@ -153,34 +212,59 @@ struct DrawKey {
|
||||
print: Option<PrintKey>,
|
||||
}
|
||||
|
||||
impl DrawKey {
|
||||
/// The revision of the image this key draws: the store renders again only when it changes.
|
||||
fn revision(&self) -> Revision {
|
||||
let c = &self.camera;
|
||||
let bits = [c.rotate_x, c.rotate_y, c.scale, c.pan[0], c.pan[1], c.perspective, c.center[0], c.center[1], c.center[2]].map(f64::to_bits);
|
||||
Revision::of(&(self.fold, c.width, c.height, bits, self.inside, self.print))
|
||||
}
|
||||
}
|
||||
|
||||
/// The last image drawn, where it sat on screen and what it shows, for picking a panel with a
|
||||
/// double-click.
|
||||
#[derive(Clone)]
|
||||
struct Shown {
|
||||
image: Arc<Image>,
|
||||
rect: Rect,
|
||||
fold: FoldKey,
|
||||
}
|
||||
|
||||
/// What the window draws this pass: the folded blank and the print to put on it.
|
||||
#[derive(Clone)]
|
||||
struct Folding {
|
||||
doc: Arc<vectorcraft_engine::doc::Document>,
|
||||
blanks: Arc<Vec<Blank>>,
|
||||
blank: usize,
|
||||
folded: Arc<Folded>,
|
||||
key: FoldKey,
|
||||
fold_ms: f64,
|
||||
print: Option<(PrintKey, Arc<Print>)>,
|
||||
}
|
||||
|
||||
/// The pass's folding, and what the status line says about it.
|
||||
struct Scene {
|
||||
blanks: usize,
|
||||
errors: bool,
|
||||
drawn: Option<Folding>,
|
||||
}
|
||||
|
||||
/// The Fold Preview window's state, kept with the add-on panels.
|
||||
#[derive(Default)]
|
||||
struct Cache {
|
||||
pub(crate) struct View {
|
||||
blanks: Option<Blanks>,
|
||||
/// The last fold, what it folds and how long it took (ms).
|
||||
folded: Option<(FoldKey, Arc<Folded>, f64)>,
|
||||
/// What the texture shows.
|
||||
drawn: Option<DrawKey>,
|
||||
/// Folds worked out and images rendered (tests count them).
|
||||
folds: u64,
|
||||
renders: u64,
|
||||
/// The print shown and what it shows.
|
||||
print: Option<(PrintKey, Arc<Print>)>,
|
||||
/// Renders the print off the UI thread (None: on this thread).
|
||||
worker: Option<ThumbWorker<(), PrintKey>>,
|
||||
worker_started: bool,
|
||||
/// The print being rendered.
|
||||
pending: Option<PrintKey>,
|
||||
/// Renders the print off the UI thread; made on the first pass, when the host is known.
|
||||
prints: Option<JobQueue<PrintKey, Option<Print>>>,
|
||||
settle: Settle,
|
||||
tex: Option<egui::TextureHandle>,
|
||||
/// The last frame's image, for double-click picking, and the screen rect it filled.
|
||||
image: Option<(Image, Rect)>,
|
||||
/// The last image drawn.
|
||||
shown: Option<Shown>,
|
||||
frame: Option<Frame>,
|
||||
/// Prints rendered (tests count them).
|
||||
prints: u64,
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static CACHE: crate::graphics::TexCache<Cache> = crate::graphics::TexCache::default();
|
||||
static RENDERER: std::cell::RefCell<vectorcraft_render::Renderer> = std::cell::RefCell::new(vectorcraft_render::Renderer::new());
|
||||
}
|
||||
|
||||
/// The board's inside color (straight RGBA) for `inside`: white when it is empty, a swatch of `d`
|
||||
@@ -210,7 +294,21 @@ fn print_size(region: DRect) -> (u32, u32, f64) {
|
||||
(side(region.width()), side(region.height()), scale)
|
||||
}
|
||||
|
||||
impl Cache {
|
||||
/// The texture store the drawn image lives in.
|
||||
fn store(ctx: &craft::egui::Context) -> TextureStore<u8> {
|
||||
TextureStore::in_context(ctx, STORE, TextureStoreOptions::default())
|
||||
}
|
||||
|
||||
/// The queue the print renders on: the host's jobs, else the default ones, with one lane (none on
|
||||
/// wasm32, where the pass runs the job).
|
||||
fn print_queue(ui: &Ui) -> JobQueue<PrintKey, Option<Print>> {
|
||||
let ctx = ui.ctx().clone();
|
||||
let jobs = Env::of(ui).view().host().map_or_else(default_jobs, |host| Arc::clone(host.jobs_shared()));
|
||||
let options = QueueOptions { lanes: QueueOptions::default_lanes().min(1), name: "fold-print" };
|
||||
JobQueue::new(jobs, Wake::new(move || ctx.request_repaint()), options)
|
||||
}
|
||||
|
||||
impl View {
|
||||
/// The blanks of document `uid` at `revision`, worked out again only when it changed.
|
||||
fn blanks(&mut self, uid: u64, revision: u64, d: &vectorcraft_engine::doc::Document) -> (Arc<Vec<Blank>>, bool) {
|
||||
if let Some((key, blanks, errors)) = &self.blanks
|
||||
@@ -237,31 +335,65 @@ impl Cache {
|
||||
let f = Arc::new(fold(blank, Some(panel), amount, TOLERANCE)?);
|
||||
let ms = crate::now_ms() - t0;
|
||||
self.folded = Some((key, f.clone(), ms));
|
||||
self.folds += 1;
|
||||
Some((f, ms))
|
||||
}
|
||||
|
||||
/// Bring the print up to `key`: on the worker when there is one, else here, and not before the
|
||||
/// document has settled unless there is no print of it yet.
|
||||
fn update_print(&mut self, ctx: &egui::Context, doc: &Arc<vectorcraft_engine::doc::Document>, key: PrintKey, region: DRect, scale: f64) {
|
||||
if !self.worker_started {
|
||||
self.worker_started = true;
|
||||
self.worker = ThumbWorker::spawn(ctx, "fold-preview");
|
||||
}
|
||||
let done = match self.worker.as_ref().map(ThumbWorker::poll) {
|
||||
Some(Some(done)) => done,
|
||||
Some(None) => {
|
||||
(self.worker, self.pending) = (None, None);
|
||||
vec![]
|
||||
}
|
||||
None => vec![],
|
||||
/// What the window draws for `doc` at `revision` with `set`: its blanks, the fold and the print.
|
||||
fn scene(&mut self, ui: &Ui, doc: &Arc<vectorcraft_engine::doc::Document>, uid: u64, revision: u64, set: &Settings) -> Scene {
|
||||
let (blanks, errors) = self.blanks(uid, revision, doc);
|
||||
let base = set.base.map(|[x, y]| Point::new(x, y));
|
||||
let picked = pick(&blanks, base).or_else(|| pick(&blanks, None));
|
||||
let drawn = picked.and_then(|(b, panel)| {
|
||||
let blank = blanks.get(b)?;
|
||||
let key = (uid, revision, b, panel, set.amount.to_bits());
|
||||
let (folded, fold_ms) = self.fold(key, blank, panel, set.amount)?;
|
||||
let print = self.print_of(ui, doc, key, blank, set.show_fold_lines);
|
||||
Some(Folding { doc: doc.clone(), blanks: blanks.clone(), blank: b, folded, key, fold_ms, print })
|
||||
});
|
||||
Scene { blanks: blanks.len(), errors, drawn }
|
||||
}
|
||||
|
||||
/// The print to draw for the fold `key` of `blank`, brought up to date first.
|
||||
fn print_of(
|
||||
&mut self,
|
||||
ui: &Ui,
|
||||
doc: &Arc<vectorcraft_engine::doc::Document>,
|
||||
key: FoldKey,
|
||||
blank: &Blank,
|
||||
fold_lines: bool,
|
||||
) -> Option<(PrintKey, Arc<Print>)> {
|
||||
let region = print_region(blank)?;
|
||||
let (width, height, scale) = print_size(region);
|
||||
let pkey = PrintKey {
|
||||
uid: key.0,
|
||||
revision: key.1,
|
||||
fold_lines,
|
||||
region: [region.x0.to_bits(), region.y0.to_bits(), region.x1.to_bits(), region.y1.to_bits()],
|
||||
width,
|
||||
height,
|
||||
};
|
||||
for d in done {
|
||||
if self.pending == Some(d.key) {
|
||||
self.update_print(ui, doc, pkey, region, scale);
|
||||
self.print_for(&pkey)
|
||||
}
|
||||
|
||||
/// Take in the prints that finished, then bring the print up to `key`: queued on the host's
|
||||
/// jobs, and not before the document has settled unless there is no print of it yet.
|
||||
fn update_print(&mut self, ui: &Ui, doc: &Arc<vectorcraft_engine::doc::Document>, key: PrintKey, region: DRect, scale: f64) {
|
||||
let queue = self.prints.get_or_insert_with(|| print_queue(ui));
|
||||
let inline = QueueOptions::default_lanes() == 0;
|
||||
if inline {
|
||||
queue.run_inline(1);
|
||||
}
|
||||
let mut done = Vec::new();
|
||||
while let Some(finished) = queue.try_recv() {
|
||||
done.push(finished);
|
||||
}
|
||||
for finished in done {
|
||||
if self.pending == Some(finished.key) {
|
||||
self.pending = None;
|
||||
}
|
||||
if let Some(img) = d.img {
|
||||
self.keep_print(d.key, img);
|
||||
if let Some(print) = finished.result {
|
||||
self.keep_print(finished.key, print);
|
||||
}
|
||||
}
|
||||
let shown = self.print.as_ref().map(|(k, _)| *k);
|
||||
@@ -269,7 +401,8 @@ impl Cache {
|
||||
return;
|
||||
}
|
||||
let have = shown.is_some_and(|k| k.uid == key.uid);
|
||||
if have && !self.settle.settled(ctx, key.uid, key.revision, ctx.input(|i| i.time)) {
|
||||
// PLAN: needs the `platform` feature of the `craft` facade in the app's Cargo.toml (not in this set's files).
|
||||
if have && !self.settle.settled(ui.ctx(), key.uid, key.revision, craft::platform::clock::monotonic_ms() / 1000.0) {
|
||||
return;
|
||||
}
|
||||
let opts = vectorcraft_render::RenderOptions {
|
||||
@@ -278,16 +411,18 @@ impl Cache {
|
||||
hidden: vectorcraft_engine::cmd::print_hidden(doc, key.fold_lines).into_iter().collect(),
|
||||
..Default::default()
|
||||
};
|
||||
if let Some(w) = &self.worker {
|
||||
let (doc, opts) = (doc.clone(), opts.clone());
|
||||
if w.submit((), key, Box::new(move |r| Some(r.render_region_with(&doc, region, scale, &opts)))) {
|
||||
self.pending = Some(key);
|
||||
return;
|
||||
}
|
||||
self.worker = None;
|
||||
let doc = doc.clone();
|
||||
let Some(queue) = &self.prints else { return };
|
||||
// A render of an older revision is of no use once this one is wanted.
|
||||
queue.reprioritize(|_, _| None);
|
||||
queue.submit(key, Priority::VISIBLE, move |_| {
|
||||
let img = vectorcraft_render::Renderer::new().render_region_with(&doc, region, scale, &opts);
|
||||
Print::new(region, img.width, img.height, img.pixels)
|
||||
});
|
||||
self.pending = Some(key);
|
||||
if inline {
|
||||
ui.ctx().request_repaint();
|
||||
}
|
||||
let img = RENDERER.with(|r| r.borrow_mut().render_region_with(doc, region, scale, &opts));
|
||||
self.keep_print(key, img);
|
||||
}
|
||||
|
||||
/// The print to draw for `want`: the one shown when it is of the same document, blank region and
|
||||
@@ -297,12 +432,23 @@ impl Cache {
|
||||
self.print.as_ref().filter(|(k, _)| same(k)).map(|(k, p)| (*k, p.clone()))
|
||||
}
|
||||
|
||||
fn keep_print(&mut self, key: PrintKey, img: vectorcraft_render::Rendered) {
|
||||
let region =
|
||||
DRect::new(f64::from_bits(key.region[0]), f64::from_bits(key.region[1]), f64::from_bits(key.region[2]), f64::from_bits(key.region[3]));
|
||||
if let Some(print) = Print::new(region, img.width, img.height, img.pixels) {
|
||||
self.print = Some((key, Arc::new(print)));
|
||||
self.prints += 1;
|
||||
fn keep_print(&mut self, key: PrintKey, print: Print) {
|
||||
self.print = Some((key, Arc::new(print)));
|
||||
}
|
||||
|
||||
/// Keep what the view drew this pass: a new image and its times, or only where the last one sits.
|
||||
fn keep(&mut self, drawn: Option<Drawn>) {
|
||||
let Some(drawn) = drawn else { return };
|
||||
match drawn.fresh {
|
||||
Some((image, frame)) => {
|
||||
self.shown = Some(Shown { image, rect: drawn.rect, fold: drawn.fold });
|
||||
self.frame = Some(frame);
|
||||
}
|
||||
None => {
|
||||
if let Some(shown) = &mut self.shown {
|
||||
shown.rect = drawn.rect;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -392,7 +538,7 @@ pub(crate) fn command(app: &mut VectorcraftApp, p: &Value) -> Result<Value, Stri
|
||||
|
||||
/// The window's settings and the last frame's size and times.
|
||||
fn state(app: &VectorcraftApp) -> Value {
|
||||
let frame = CACHE.with(|c| c.borrow().frame);
|
||||
let frame = app.addon_panels.fold_view.frame;
|
||||
let mut out = serde_json::to_value(&app.ui.fold_preview).unwrap_or_default();
|
||||
if let Some(o) = out.as_object_mut() {
|
||||
o.insert(
|
||||
@@ -403,122 +549,46 @@ fn state(app: &VectorcraftApp) -> Value {
|
||||
out
|
||||
}
|
||||
|
||||
/// The toolbar: the view presets, Perspective, Inside, Show Fold Lines and Reset.
|
||||
fn toolbar(app: &VectorcraftApp, ui: &mut Ui, set: &mut Settings) {
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
let labels: Vec<&str> = VIEWS.iter().map(|v| v.0).collect();
|
||||
let current = set.view().map_or("", |v| v.0);
|
||||
if let Some(i) = widgets::dropdown_named(ui, "fold-preview-view", Some(tl!("View")), current, &labels, 120.0)
|
||||
&& let Some(&(_, _, x, y)) = VIEWS.get(i)
|
||||
/// The toolbar: the view presets, Inside, Show Fold Lines and Reset.
|
||||
fn toolbar(ui: &mut Ui, words: &FoldPreviewWords, doc: &vectorcraft_engine::doc::Document, set: &mut Settings) {
|
||||
let views: Vec<Entry<&'static str>> = VIEWS.iter().map(|v| Entry::new(v.1, words.view_label(v.1))).collect();
|
||||
let solid = |s: &&vectorcraft_color::Swatch| matches!(s.paint, vectorcraft_color::Paint::Solid { .. });
|
||||
let insides: Vec<Entry<String>> = std::iter::once(Entry::new(String::new(), words.white.clone()))
|
||||
.chain(doc.swatches.iter().filter(solid).map(|s| Entry::new(s.name.clone(), s.name.clone())))
|
||||
.collect();
|
||||
Row::new().wrap(true).show(ui, |ui, _| {
|
||||
let current = set.view().map_or("", |v| v.1);
|
||||
if let Some(&id) = Select::new(words.view.clone(), Bind::given(current), &views).show(ui).value()
|
||||
&& let Some(&(_, _, x, y)) = VIEWS.iter().find(|v| v.1 == id)
|
||||
{
|
||||
(set.rotate_x, set.rotate_y, set.pan) = (x, y, [0.0; 2]);
|
||||
}
|
||||
let swatches: Vec<String> = app.session.active().map_or_else(Vec::new, |st| {
|
||||
st.doc.swatches.iter().filter(|s| matches!(s.paint, vectorcraft_color::Paint::Solid { .. })).map(|s| s.name.clone()).collect()
|
||||
});
|
||||
let mut names: Vec<&str> = vec![tl!("White")];
|
||||
names.extend(swatches.iter().map(String::as_str));
|
||||
let shown = if set.inside.is_empty() { tl!("White") } else { set.inside.as_str() };
|
||||
ui.label(tl!("Inside"));
|
||||
if let Some(i) = widgets::dropdown_names_named(ui, "fold-preview-inside", Some(tl!("Inside")), shown, &names, 110.0) {
|
||||
set.inside = swatches.get(i.wrapping_sub(1)).cloned().unwrap_or_default();
|
||||
let inside = Select::new(words.inside.clone(), Bind::given(set.inside.clone()), &insides).placeholder(set.inside.clone()).show(ui);
|
||||
if let Some(name) = inside.value() {
|
||||
set.inside.clone_from(name);
|
||||
}
|
||||
if widgets::check(ui, tl!("Show Fold Lines"), set.show_fold_lines, true) {
|
||||
set.show_fold_lines = !set.show_fold_lines;
|
||||
}
|
||||
if widgets::flat_button_fit(ui, tl!("Reset"), 48.0).clicked() {
|
||||
Checkbox::new(Bind::bound(&mut set.show_fold_lines)).label(words.show_fold_lines.clone()).show(ui);
|
||||
if Button::new(words.reset.clone()).show(ui).clicks > 0 {
|
||||
let fresh = Settings::default();
|
||||
(set.rotate_x, set.rotate_y, set.zoom, set.pan, set.perspective) = (fresh.rotate_x, fresh.rotate_y, 1.0, [0.0; 2], 0.0);
|
||||
}
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(tl!("Perspective"));
|
||||
widgets::slider(ui, egui::Slider::new(&mut set.perspective, 0.0..=160.0).suffix("°").fixed_decimals(0));
|
||||
});
|
||||
}
|
||||
|
||||
/// The Fold and Zoom sliders.
|
||||
fn sliders(ui: &mut Ui, set: &mut Settings) {
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(tl!("Fold"));
|
||||
let mut percent = set.amount * 100.0;
|
||||
if widgets::slider(ui, egui::Slider::new(&mut percent, 0.0..=100.0).suffix("%").fixed_decimals(0)).changed() {
|
||||
set.amount = (percent / 100.0).clamp(0.0, 1.0);
|
||||
}
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(tl!("Zoom"));
|
||||
let mut percent = set.zoom * 100.0;
|
||||
if widgets::slider(ui, egui::Slider::new(&mut percent, 10.0..=800.0).suffix("%").fixed_decimals(0).logarithmic(true)).changed() {
|
||||
set.zoom = (percent / 100.0).clamp(0.1, 8.0);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Turns, moves and zooms the view with the pointer, the wheel and the arrow keys, and picks the
|
||||
/// base panel of `blank` (the blank `key` folds) on a double-click.
|
||||
fn interact(ui: &Ui, response: &egui::Response, set: &mut Settings, blank: Option<(&Blank, FoldKey)>) {
|
||||
if response.clicked() || response.drag_started() {
|
||||
response.request_focus();
|
||||
}
|
||||
let (shift, space) = ui.input(|i| (i.modifiers.shift, i.key_down(egui::Key::Space)));
|
||||
let delta = response.drag_delta();
|
||||
if delta != egui::Vec2::ZERO {
|
||||
if response.dragged_by(egui::PointerButton::Middle) || (space && response.dragged_by(egui::PointerButton::Primary)) {
|
||||
set.pan[0] += f64::from(delta.x);
|
||||
set.pan[1] += f64::from(delta.y);
|
||||
} else if response.dragged_by(egui::PointerButton::Primary) {
|
||||
let (mut dx, mut dy) = (f64::from(delta.x), f64::from(delta.y));
|
||||
if shift {
|
||||
if dx.abs() >= dy.abs() {
|
||||
dy = 0.0;
|
||||
} else {
|
||||
dx = 0.0;
|
||||
}
|
||||
}
|
||||
set.rotate_y = wrapped(set.rotate_y + dx * DRAG_TURN);
|
||||
set.rotate_x = wrapped(set.rotate_x + dy * DRAG_TURN);
|
||||
}
|
||||
}
|
||||
if response.hovered() {
|
||||
let scroll = f64::from(ui.input(|i| i.smooth_scroll_delta.y + (i.zoom_delta() - 1.0) * 200.0));
|
||||
if scroll != 0.0 {
|
||||
set.zoom = (set.zoom * (scroll * 0.002).exp()).clamp(0.1, 8.0);
|
||||
}
|
||||
}
|
||||
if response.has_focus() {
|
||||
// The view keeps the arrow keys, so they turn it rather than move the focus on.
|
||||
ui.memory_mut(|m| {
|
||||
m.set_focus_lock_filter(response.id, egui::EventFilter { horizontal_arrows: true, vertical_arrows: true, ..Default::default() })
|
||||
});
|
||||
let presses = |key| ui.input_mut(|i| i.count_and_consume_key(egui::Modifiers::NONE, key)) as f64 * KEY_TURN;
|
||||
let (left, right, up, down) =
|
||||
(presses(egui::Key::ArrowLeft), presses(egui::Key::ArrowRight), presses(egui::Key::ArrowUp), presses(egui::Key::ArrowDown));
|
||||
if left + right + up + down > 0.0 {
|
||||
set.rotate_y = wrapped(set.rotate_y + right - left);
|
||||
set.rotate_x = wrapped(set.rotate_x + down - up);
|
||||
}
|
||||
}
|
||||
if response.double_clicked()
|
||||
&& let Some(pos) = response.interact_pointer_pos()
|
||||
&& let Some((blank, key)) = blank
|
||||
{
|
||||
// The image on screen is the last one drawn; its panel numbers are used only while it shows
|
||||
// the same blank of the same document revision.
|
||||
let picked = CACHE.with(|c| {
|
||||
let c = c.borrow();
|
||||
let shown = c.drawn.map(|d| (d.fold.0, d.fold.1, d.fold.2));
|
||||
if shown != Some((key.0, key.1, key.2)) {
|
||||
return None;
|
||||
}
|
||||
let (img, rect) = c.image.as_ref()?;
|
||||
let x = (pos.x - rect.left()) / rect.width() * img.width as f32;
|
||||
let y = (pos.y - rect.top()) / rect.height() * img.height as f32;
|
||||
img.panel_at(x.max(0.0) as u32, y.max(0.0) as u32)
|
||||
});
|
||||
if let Some(p) = picked.and_then(|i| blank.panels.get(i)).and_then(|p| p.point_inside()) {
|
||||
set.base = Some([p.x, p.y]);
|
||||
}
|
||||
/// A slider over `value` as a percentage, which keeps `value` within `range` (as fractions).
|
||||
// PLAN: the sheet says `Field` + `Slider`; `SliderField` is the one component with the caption, number field and slider, and the percent unit keeps the old window's look.
|
||||
fn percent_slider(ui: &mut Ui, label: Label, value: &mut f64, range: RangeInclusive<f64>, scale: SliderScale) {
|
||||
let before = *value * 100.0;
|
||||
let mut shown = before;
|
||||
let bounds = (range.start() * 100.0)..=(range.end() * 100.0);
|
||||
SliderField::new(label, Bind::bound(&mut shown), bounds)
|
||||
.layout(SliderFieldLayout::Inline)
|
||||
.scale(scale)
|
||||
.step(1.0)
|
||||
.unit_kind(UnitKind::Percent)
|
||||
.show(ui);
|
||||
if shown != before {
|
||||
*value = (shown / 100.0).clamp(*range.start(), *range.end());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -546,6 +616,7 @@ fn status(blanks: usize, folded: Option<(&Blank, &Folded)>, errors: bool) -> Vec
|
||||
out
|
||||
}
|
||||
|
||||
/// Shows the Fold Preview window: the toolbar, the folded blank, the status lines and the sliders.
|
||||
pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
||||
let Some(st) = app.session.active() else {
|
||||
crate::panels::empty_state(ui, "box", tl!("No document"), tl!("Open a document to preview its folded shape."));
|
||||
@@ -553,152 +624,261 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
|
||||
};
|
||||
let (uid, revision, doc) = (st.uid, st.revision, st.doc.clone());
|
||||
let mut set = app.ui.fold_preview.clone().clamped();
|
||||
toolbar(app, ui, &mut set);
|
||||
let (blanks, errors) = CACHE.with(|c| c.borrow_mut().blanks(uid, revision, &doc));
|
||||
let base_point = set.base.map(|[x, y]| Point::new(x, y));
|
||||
let picked = pick(&blanks, base_point).or_else(|| pick(&blanks, None));
|
||||
let folded = picked.and_then(|(b, panel)| {
|
||||
let blank = blanks.get(b)?;
|
||||
let key = (uid, revision, b, panel, set.amount.to_bits());
|
||||
let (f, ms) = CACHE.with(|c| c.borrow_mut().fold(key, blank, panel, set.amount))?;
|
||||
Some((blank, f, key, ms))
|
||||
let words = Env::of(ui).words::<FoldPreviewWords>();
|
||||
let view = &mut app.addon_panels.fold_view;
|
||||
let mut drawn = None;
|
||||
Stack::new().fill().show(ui, |ui, _| {
|
||||
toolbar(ui, &words, &doc, &mut set);
|
||||
SliderField::new(words.perspective.clone(), Bind::bound(&mut set.perspective), 0.0..=160.0)
|
||||
.layout(SliderFieldLayout::Inline)
|
||||
.step(1.0)
|
||||
.unit_kind(UnitKind::Degrees)
|
||||
.show(ui);
|
||||
let scene = view.scene(ui, &doc, uid, revision, &set);
|
||||
let out = FoldView::new(words.image.clone(), set.clone(), scene.drawn.clone(), view.shown.clone()).sizing(Sizing::Fill).show(ui);
|
||||
set = out.set;
|
||||
drawn = out.drawn;
|
||||
let folded = scene.drawn.as_ref().and_then(|d| Some((d.blanks.get(d.blank)?, &*d.folded)));
|
||||
for line in status(scene.blanks, folded, scene.errors) {
|
||||
Text::new(crate::i18n::msg(&line)).shade(Shade::Muted).show(ui);
|
||||
}
|
||||
percent_slider(ui, words.fold.clone(), &mut set.amount, 0.0..=1.0, SliderScale::Linear);
|
||||
percent_slider(ui, words.zoom.clone(), &mut set.zoom, 0.1..=8.0, SliderScale::Log);
|
||||
});
|
||||
|
||||
let bottom = ui.spacing().interact_size.y * 3.0 + 12.0;
|
||||
let size = vec2(ui.available_width().max(64.0), (ui.available_height() - bottom).max(64.0));
|
||||
let (rect, response) = ui.allocate_exact_size(size, Sense::click_and_drag());
|
||||
let view_name = set.view().map_or("", |v| v.0);
|
||||
response.widget_info(|| {
|
||||
let mut info = egui::WidgetInfo::labeled(egui::Role::Image, true, tl!("Fold Preview"));
|
||||
info.current_text_value = Some(crate::i18n::t(view_name).to_string());
|
||||
info
|
||||
});
|
||||
interact(ui, &response, &mut set, folded.as_ref().map(|(b, _, key, _)| (*b, *key)));
|
||||
let t = crate::theme::Tokens::get(ui.ctx());
|
||||
ui.painter().rect_filled(rect, 2.0, t.pasteboard);
|
||||
if let Some((blank, f, key, fold_ms)) = &folded {
|
||||
draw(ui, rect, &doc, *key, blank, f, &set, *fold_ms);
|
||||
}
|
||||
if response.has_focus() {
|
||||
ui.painter().rect_stroke(rect, 2.0, egui::Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
|
||||
}
|
||||
for line in status(blanks.len(), folded.as_ref().map(|(b, f, ..)| (*b, &**f)), errors) {
|
||||
dim_label(ui, &crate::i18n::msg(&line));
|
||||
}
|
||||
sliders(ui, &mut set);
|
||||
view.keep(drawn);
|
||||
if set != app.ui.fold_preview {
|
||||
app.ui.fold_preview = set;
|
||||
}
|
||||
}
|
||||
|
||||
/// Draws `blank` folded as `f` (the fold `key` names) into `rect`, with the print of `doc`. The image
|
||||
/// is rendered again only when the fold, the view, the inside color or the print changed.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn draw(ui: &Ui, rect: Rect, doc: &Arc<vectorcraft_engine::doc::Document>, key: FoldKey, blank: &Blank, f: &Folded, set: &Settings, fold_ms: f64) {
|
||||
// Pixels per point of the view, lowered when the window has more pixels than the view may have
|
||||
// in all or along either side, so the image keeps the window's proportions.
|
||||
let (w, h) = (f64::from(rect.width()), f64::from(rect.height()));
|
||||
let mut ppp = f64::from(ui.ctx().pixels_per_point());
|
||||
let area = w * h * ppp * ppp;
|
||||
if area > f64::from(MAX_PIXELS) {
|
||||
ppp *= (f64::from(MAX_PIXELS) / area).sqrt();
|
||||
/// What the view drew in one pass: where, which fold, and the image when it was rendered anew.
|
||||
struct Drawn {
|
||||
rect: Rect,
|
||||
fold: FoldKey,
|
||||
fresh: Option<(Arc<Image>, Frame)>,
|
||||
}
|
||||
|
||||
/// What the folded view reports in one pass.
|
||||
#[derive(Debug)]
|
||||
struct FoldViewOutput {
|
||||
response: Response,
|
||||
/// The settings after this pass's gestures.
|
||||
set: Settings,
|
||||
drawn: Option<Drawn>,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Drawn {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("Drawn").field("rect", &self.rect).field("fold", &self.fold).finish_non_exhaustive()
|
||||
}
|
||||
ppp = ppp.min(f64::from(MAX_SIDE) / w.max(h).max(1.0));
|
||||
let width = ((w * ppp).floor() as u32).clamp(1, MAX_SIDE);
|
||||
let height = ((h * ppp).floor() as u32).clamp(1, MAX_SIDE);
|
||||
let Some((lo, hi)) = raster::bounds(blank, f) else { return };
|
||||
let center = [(lo[0] + hi[0]) / 2.0, (lo[1] + hi[1]) / 2.0, (lo[2] + hi[2]) / 2.0];
|
||||
let radius = ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2) + (hi[2] - lo[2]).powi(2)).sqrt() / 2.0;
|
||||
let mut fit = FIT * f64::from(width.min(height)) / radius.max(1e-6);
|
||||
if set.perspective > 0.0 {
|
||||
// The eye at two radii from the middle or farther, so at a zoom of 1 the whole blank is in
|
||||
// front of it.
|
||||
let focal = f64::from(width.min(height)) / 2.0 / (set.perspective.to_radians() / 2.0).tan();
|
||||
fit = fit.min(focal / (2.0 * radius.max(1e-6)));
|
||||
}
|
||||
|
||||
impl Outcome for FoldViewOutput {
|
||||
type Value = NoValue;
|
||||
|
||||
fn response(&self) -> &Response {
|
||||
&self.response
|
||||
}
|
||||
let camera = Camera {
|
||||
width,
|
||||
height,
|
||||
rotate_x: set.rotate_x,
|
||||
rotate_y: set.rotate_y,
|
||||
scale: fit * set.zoom,
|
||||
pan: [set.pan[0] * ppp, set.pan[1] * ppp],
|
||||
perspective: set.perspective,
|
||||
center,
|
||||
};
|
||||
let inside = inside_color(doc, &set.inside).unwrap_or([255; 4]);
|
||||
// While the print of a new revision renders, the last one of the same blank and setting is
|
||||
// drawn; a print of another document, blank or Show Fold Lines setting is not.
|
||||
let print = CACHE.with(|c| {
|
||||
let mut c = c.borrow_mut();
|
||||
let region = print_region(blank)?;
|
||||
let (pw, ph, scale) = print_size(region);
|
||||
let pkey = PrintKey {
|
||||
uid: key.0,
|
||||
revision: key.1,
|
||||
fold_lines: set.show_fold_lines,
|
||||
region: [region.x0.to_bits(), region.y0.to_bits(), region.x1.to_bits(), region.y1.to_bits()],
|
||||
width: pw,
|
||||
height: ph,
|
||||
};
|
||||
c.update_print(ui.ctx(), doc, pkey, region, scale);
|
||||
c.print_for(&pkey)
|
||||
});
|
||||
let draw_key = DrawKey { fold: key, camera, inside, print: print.as_ref().map(|(k, _)| *k) };
|
||||
let kept = CACHE.with(|c| {
|
||||
let mut c = c.borrow_mut();
|
||||
let Some(tex) = c.tex.as_ref().filter(|_| c.drawn == Some(draw_key)).map(|t| t.id()) else { return false };
|
||||
ui.painter().image(tex, rect, Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)), Color32::WHITE);
|
||||
if let Some((_, at)) = &mut c.image {
|
||||
*at = rect;
|
||||
}
|
||||
true
|
||||
});
|
||||
if kept {
|
||||
return;
|
||||
}
|
||||
|
||||
/// The style of the folded view: the room it asks for and its focus ring.
|
||||
#[derive(Clone, Debug, PartialEq, ComponentStyle)]
|
||||
struct FoldViewStyle {
|
||||
#[style(metrics)]
|
||||
metrics: Metrics,
|
||||
#[style(focus)]
|
||||
focus: FocusLook,
|
||||
}
|
||||
|
||||
/// The folded blank, drawn into the room it is given. A drag turns the view (Shift keeps to one
|
||||
/// axis), a middle drag or a drag with Space held moves it, the wheel zooms, the arrow keys turn it by
|
||||
/// [`KEY_TURN`], and a double click on a panel picks it as the base. The settings it reports are
|
||||
/// the ones it was given with the gestures applied.
|
||||
#[derive(craft::ui::contract::Component, craft::ui::contract::Props)]
|
||||
#[component(content_painter, sample = FoldView::sample)]
|
||||
struct FoldView {
|
||||
#[common]
|
||||
common: Common,
|
||||
set: Settings,
|
||||
folding: Option<Folding>,
|
||||
/// The last image drawn, which a double click picks a panel from.
|
||||
last: Option<Shown>,
|
||||
drawn: Option<Drawn>,
|
||||
}
|
||||
|
||||
impl FoldView {
|
||||
/// A view of `folding` under `set`, named `label`.
|
||||
fn new(label: impl Into<Label>, set: Settings, folding: Option<Folding>, last: Option<Shown>) -> Self {
|
||||
FoldView { common: Common::new(), set, folding, last, drawn: None }.label(label)
|
||||
}
|
||||
let t0 = crate::now_ms();
|
||||
let scene = raster::Scene { blank, folded: f, print: print.as_ref().map(|(_, p)| &**p), inside, outside: [255; 4], camera };
|
||||
let Some(img) = raster::render(&scene) else { return };
|
||||
let draw_ms = crate::now_ms() - t0;
|
||||
let color = egui::ColorImage::from_rgba_premultiplied([img.width as usize, img.height as usize], &img.pixels);
|
||||
CACHE.with(|c| {
|
||||
let mut c = c.borrow_mut();
|
||||
c.drawn = Some(draw_key);
|
||||
c.renders += 1;
|
||||
match &mut c.tex {
|
||||
Some(tex) => tex.set(color, egui::TextureOptions::LINEAR),
|
||||
None => c.tex = Some(ui.ctx().load_texture("fold-preview", color, egui::TextureOptions::LINEAR)),
|
||||
|
||||
/// An empty view, for the suite.
|
||||
fn sample() -> Self {
|
||||
FoldView::new("Fold Preview", Settings::default(), None, None)
|
||||
}
|
||||
|
||||
/// The base point of the panel at `at` in the last image drawn, while that image shows the
|
||||
/// blank now folded of the same document revision.
|
||||
fn pick(&self, at: Pos2) -> Option<[f64; 2]> {
|
||||
let (folding, shown) = (self.folding.as_ref()?, self.last.as_ref()?);
|
||||
if (shown.fold.0, shown.fold.1, shown.fold.2) != (folding.key.0, folding.key.1, folding.key.2) {
|
||||
return None;
|
||||
}
|
||||
if let Some(tex) = &c.tex {
|
||||
let uv = Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0));
|
||||
ui.painter().image(tex.id(), rect, uv, Color32::WHITE);
|
||||
let (img, rect) = (&shown.image, shown.rect);
|
||||
let x = (at.x - rect.left()) / rect.width() * img.width as f32;
|
||||
let y = (at.y - rect.top()) / rect.height() * img.height as f32;
|
||||
let panel = img.panel_at(x.max(0.0) as u32, y.max(0.0) as u32)?;
|
||||
let p = folding.blanks.get(folding.blank)?.panels.get(panel)?.point_inside()?;
|
||||
Some([p.x, p.y])
|
||||
}
|
||||
|
||||
/// The camera for `blank` folded as `f` in an image of `width` × `height` pixels at `ppp` pixels
|
||||
/// a point.
|
||||
fn camera(&self, blank: &Blank, f: &Folded, width: u32, height: u32, ppp: f64) -> Option<Camera> {
|
||||
let set = &self.set;
|
||||
let (lo, hi) = raster::bounds(blank, f)?;
|
||||
let center = [(lo[0] + hi[0]) / 2.0, (lo[1] + hi[1]) / 2.0, (lo[2] + hi[2]) / 2.0];
|
||||
let radius = ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2) + (hi[2] - lo[2]).powi(2)).sqrt() / 2.0;
|
||||
let mut fit = FIT * f64::from(width.min(height)) / radius.max(1e-6);
|
||||
if set.perspective > 0.0 {
|
||||
// The eye at two radii from the middle or farther, so at a zoom of 1 the whole blank is
|
||||
// in front of it.
|
||||
let focal = f64::from(width.min(height)) / 2.0 / (set.perspective.to_radians() / 2.0).tan();
|
||||
fit = fit.min(focal / (2.0 * radius.max(1e-6)));
|
||||
}
|
||||
c.frame = Some(Frame { width: img.width, height: img.height, fold_ms, draw_ms });
|
||||
c.image = Some((img, rect));
|
||||
});
|
||||
Some(Camera {
|
||||
width,
|
||||
height,
|
||||
rotate_x: set.rotate_x,
|
||||
rotate_y: set.rotate_y,
|
||||
scale: fit * set.zoom,
|
||||
pan: [set.pan[0] * ppp, set.pan[1] * ppp],
|
||||
perspective: set.perspective,
|
||||
center,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn prints_rendered() -> u64 {
|
||||
CACHE.with(|c| c.borrow().prints)
|
||||
}
|
||||
impl Component for FoldView {
|
||||
const ROLE: Role = Role::IMAGE;
|
||||
const PARTS: bool = false;
|
||||
const OVERLAYS: bool = false;
|
||||
const SHOWS_LABEL: bool = false;
|
||||
/// The view keeps the arrow keys, so they turn it rather than move the focus on.
|
||||
const KEYS: KeyUse = KeyUse::of(Input::Pointer).with_keep(KeepKeys::BlockArrows).with_activate(ActivateKeys::Neither);
|
||||
type Style = FoldViewStyle;
|
||||
type Output = FoldViewOutput;
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn last_image() -> Option<Image> {
|
||||
CACHE.with(|c| c.borrow().image.as_ref().map(|(i, _)| i.clone()))
|
||||
}
|
||||
fn style(cx: &StyleCx<'_>, _: FoldViewStyleKey) -> FoldViewStyle {
|
||||
let plot = &cx.tokens.size.plot;
|
||||
FoldViewStyle { metrics: Metrics::new().min_size(Vec2::splat(plot.width.min(plot.height))), focus: cx.focus_look() }
|
||||
}
|
||||
|
||||
/// The folds worked out and the images rendered so far.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn work_done() -> (u64, u64) {
|
||||
CACHE.with(|c| (c.borrow().folds, c.borrow().renders))
|
||||
}
|
||||
fn measure(&mut self, _: &MeasureCx<'_, Self>) -> Vec2 {
|
||||
Vec2::ZERO
|
||||
}
|
||||
|
||||
/// The screen rect the last image filled.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn last_rect() -> Option<Rect> {
|
||||
CACHE.with(|c| c.borrow().image.as_ref().map(|(_, r)| *r))
|
||||
fn sense(&self) -> Sense {
|
||||
Sense::CLICK | Sense::DRAG | Sense::FOCUS | Sense::TAKE_FOCUS | Sense::WHEEL
|
||||
}
|
||||
|
||||
fn update(&mut self, cx: &mut Cx<'_, Self>) {
|
||||
let (phase, mods) = (cx.press().phase, cx.press().mods);
|
||||
match phase {
|
||||
PressPhase::Drag { start, delta, .. } => {
|
||||
let (mut dx, mut dy) = (f64::from(delta.x), f64::from(delta.y));
|
||||
let space = keys::held(&cx.response.ctx).contains(&Key::Space);
|
||||
if start.button == PointerButton::Middle || (start.button == PointerButton::Primary && space) {
|
||||
self.set.pan[0] += dx;
|
||||
self.set.pan[1] += dy;
|
||||
} else if start.button == PointerButton::Primary {
|
||||
if mods.shift {
|
||||
if dx.abs() >= dy.abs() {
|
||||
dy = 0.0;
|
||||
} else {
|
||||
dx = 0.0;
|
||||
}
|
||||
}
|
||||
self.set.rotate_y = wrapped(self.set.rotate_y + dx * DRAG_TURN);
|
||||
self.set.rotate_x = wrapped(self.set.rotate_x + dy * DRAG_TURN);
|
||||
}
|
||||
}
|
||||
PressPhase::Release { start, pos, click: true, .. } if start.button == PointerButton::Primary && start.clicks == 2 => {
|
||||
if let Some(base) = self.pick(pos) {
|
||||
self.set.base = Some(base);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if let Some(wheel) = cx.take_wheel() {
|
||||
let scroll = f64::from(wheel.scroll.y + (wheel.zoom - 1.0) * 200.0);
|
||||
if scroll != 0.0 {
|
||||
self.set.zoom = (self.set.zoom * (scroll * 0.002).exp()).clamp(0.1, 8.0);
|
||||
}
|
||||
}
|
||||
let rtl = cx.flow.is_rtl();
|
||||
let (mut turn_y, mut turn_x) = (0.0, 0.0);
|
||||
while let Some((step, _)) = cx.intents().take_move() {
|
||||
match (step, rtl) {
|
||||
(NavMove::Back, false) | (NavMove::Forward, true) => turn_y -= KEY_TURN,
|
||||
(NavMove::Forward, false) | (NavMove::Back, true) => turn_y += KEY_TURN,
|
||||
(NavMove::Up, _) => turn_x -= KEY_TURN,
|
||||
(NavMove::Down, _) => turn_x += KEY_TURN,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if turn_x != 0.0 || turn_y != 0.0 {
|
||||
self.set.rotate_y = wrapped(self.set.rotate_y + turn_y);
|
||||
self.set.rotate_x = wrapped(self.set.rotate_x + turn_x);
|
||||
}
|
||||
}
|
||||
|
||||
fn value_text(&self, cx: &Cx<'_, Self>) -> Option<String> {
|
||||
let words = cx.words::<FoldPreviewWords>();
|
||||
let view = self.set.view()?;
|
||||
Some(cx.env.resolve(&words.view_label(view.1)).as_str().to_owned())
|
||||
}
|
||||
|
||||
/// The image is rendered at the view's size, lowered when the window has more pixels than the
|
||||
/// view may have in all or along either side, so it keeps the window's proportions; it is
|
||||
/// rendered again only when the fold, the view, the inside color or the print changed.
|
||||
fn paint(&mut self, ui: &mut PaintUi<'_>, cx: &Cx<'_, Self>) {
|
||||
ui.draw().surface(cx.rect, SurfaceKind::Canvas, Default::default());
|
||||
let Some(folding) = &self.folding else { return };
|
||||
let Some(blank) = folding.blanks.get(folding.blank) else { return };
|
||||
let ctx = &cx.response.ctx;
|
||||
let (w, h) = (f64::from(cx.rect.width()), f64::from(cx.rect.height()));
|
||||
let mut ppp = f64::from(ctx.pixels_per_point());
|
||||
let area = w * h * ppp * ppp;
|
||||
if area > f64::from(MAX_PIXELS) {
|
||||
ppp *= (f64::from(MAX_PIXELS) / area).sqrt();
|
||||
}
|
||||
ppp = ppp.min(f64::from(MAX_SIDE) / w.max(h).max(1.0));
|
||||
let width = ((w * ppp).floor() as u32).clamp(1, MAX_SIDE);
|
||||
let height = ((h * ppp).floor() as u32).clamp(1, MAX_SIDE);
|
||||
let Some(camera) = self.camera(blank, &folding.folded, width, height, ppp) else { return };
|
||||
let inside = inside_color(&folding.doc, &self.set.inside).unwrap_or([255; 4]);
|
||||
let print = folding.print.as_ref();
|
||||
let key = DrawKey { fold: folding.key, camera, inside, print: print.map(|(k, _)| *k) };
|
||||
let mut fresh = None;
|
||||
let texture = store(ctx).get_or_put(ctx, 0, key.revision(), || {
|
||||
let t0 = crate::now_ms();
|
||||
let scene = raster::Scene { blank, folded: &folding.folded, print: print.map(|(_, p)| &**p), inside, outside: [255; 4], camera };
|
||||
let Some(img) = raster::render(&scene) else {
|
||||
return ColorImage::from_rgba_premultiplied([1, 1], &[0; 4]);
|
||||
};
|
||||
let color = ColorImage::from_rgba_premultiplied([img.width as usize, img.height as usize], &img.pixels);
|
||||
let frame = Frame { width: img.width, height: img.height, fold_ms: folding.fold_ms, draw_ms: crate::now_ms() - t0 };
|
||||
fresh = Some((Arc::new(img), frame));
|
||||
color
|
||||
});
|
||||
ui.draw().texture(cx.rect, texture.id, Rect::from_min_max(Pos2::ZERO, pos2(1.0, 1.0)));
|
||||
self.drawn = Some(Drawn { rect: cx.rect, fold: folding.key, fresh });
|
||||
}
|
||||
|
||||
fn finish(self, cx: Cx<'_, Self>) -> FoldViewOutput {
|
||||
FoldViewOutput { response: cx.response.clone(), set: self.set, drawn: self.drawn }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -1,12 +1,20 @@
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use craft::egui::{Event, Key, Modifiers, PointerButton, Pos2, Vec2, vec2};
|
||||
use craft::ui::testing::fixture::Fixture;
|
||||
use craft::ui::testing::frames::Frames;
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_engine::Session;
|
||||
use vectorcraft_three_d::fold::raster::{Image, MAX_PIXELS, MAX_SIDE};
|
||||
|
||||
use std::sync::Arc;
|
||||
use super::{PrintKey, Settings, Shown, View, inside_color, show, status, store};
|
||||
use crate::VectorcraftApp;
|
||||
|
||||
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
|
||||
|
||||
use super::{Cache, ID, PrintKey, Settings, inside_color, last_image, last_rect, prints_rendered, show, status, work_done};
|
||||
use crate::{VectorcraftApp, menus};
|
||||
/// How long a test waits for the print to render.
|
||||
const PRINT_WAIT: Duration = Duration::from_secs(30);
|
||||
|
||||
/// An app with a tray blank (a 100 pt base at x 140 to 240, y 140 to 240, and a 40 pt wall on each
|
||||
/// side) and a red square printed on the base, nothing selected → (app, the red square's id).
|
||||
@@ -32,48 +40,76 @@ fn app() -> (VectorcraftApp, u64) {
|
||||
(app, red)
|
||||
}
|
||||
|
||||
/// Draws the window in a 520 × 440 frame, twice (egui lays out on the first).
|
||||
fn frame(app: &mut VectorcraftApp) {
|
||||
frame_at(app, 1.0);
|
||||
}
|
||||
|
||||
/// [`frame`] at `zoom` pixels per point.
|
||||
fn frame_at(app: &mut VectorcraftApp, zoom: f32) {
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let ctx = egui::Context::default();
|
||||
ctx.set_pixels_per_point(zoom);
|
||||
crate::theme::install_fonts(&ctx);
|
||||
for time in [0.0, 1.0] {
|
||||
let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(520.0, 440.0));
|
||||
let input = egui::RawInput { time: Some(time), screen_rect: Some(screen), ..Default::default() };
|
||||
let mut out = ctx.run_ui(input, |ui| show(app, ui));
|
||||
out.textures_delta.clear();
|
||||
}
|
||||
}
|
||||
|
||||
fn color_at(img: &vectorcraft_three_d::fold::raster::Image, x: u32, y: u32) -> [u8; 4] {
|
||||
fn color_at(img: &Image, x: u32, y: u32) -> [u8; 4] {
|
||||
let i = (y * img.width + x) as usize * 4;
|
||||
[img.pixels[i], img.pixels[i + 1], img.pixels[i + 2], img.pixels[i + 3]]
|
||||
}
|
||||
|
||||
/// The color at the middle of the window's last image.
|
||||
fn middle(img: &vectorcraft_three_d::fold::raster::Image) -> [u8; 4] {
|
||||
fn middle(img: &Image) -> [u8; 4] {
|
||||
color_at(img, img.width / 2, img.height / 2)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_menu_item_and_the_panel_button_show_the_window_and_a_second_run_keeps_it() {
|
||||
let (mut app, _) = app();
|
||||
let entries = menus::menu_entries(&app);
|
||||
let item = entries.iter().find(|e| e.path == ["Object", "Plug-ins", "Packaging Tools"] && e.label == "Fold Preview").expect("listed");
|
||||
assert_eq!((item.command.as_deref(), &item.params), (Some("ui.foldPreview"), &json!({})));
|
||||
assert!(!crate::panel_docking::showing(&app.ui, ID));
|
||||
menus::invoke(&mut app, "ui.foldPreview", json!({}));
|
||||
assert!(crate::panel_docking::visible(&app.ui, ID), "the window opens");
|
||||
menus::invoke(&mut app, "ui.foldPreview", json!({}));
|
||||
assert!(crate::panel_docking::visible(&app.ui, ID), "a second run leaves it open");
|
||||
let text = crate::tests_labels::painted_text(&mut app, super::super::show);
|
||||
assert!(text.contains("Fold Preview"), "the Fold Lines panel has the button: {text}");
|
||||
/// The window in a room of `room` points at `ppp` pixels a point, over frames of the app's own.
|
||||
struct Window {
|
||||
frames: Frames,
|
||||
room: Vec2,
|
||||
}
|
||||
|
||||
impl Window {
|
||||
fn new(ppp: f32, room: Vec2) -> Self {
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let mut frames = Frames::new();
|
||||
frames.pixels_per_point(ppp);
|
||||
Window { frames, room }
|
||||
}
|
||||
|
||||
fn frame(&mut self, app: &mut VectorcraftApp) {
|
||||
let room = self.room;
|
||||
self.frames.frame(vec![], |ui| {
|
||||
ui.allocate_ui(room, |ui| show(app, ui));
|
||||
});
|
||||
}
|
||||
|
||||
/// Frames until the print of the document as it is has been rendered and drawn.
|
||||
fn settle(&mut self, app: &mut VectorcraftApp) -> Shown {
|
||||
for _ in 0..SETTLE_FRAMES {
|
||||
self.frame(app);
|
||||
if print_ready(app) {
|
||||
break;
|
||||
}
|
||||
wait_for_print(app);
|
||||
}
|
||||
assert!(print_ready(app), "the print renders");
|
||||
for _ in 0..3 {
|
||||
self.frame(app);
|
||||
}
|
||||
app.addon_panels.fold_view.shown.clone().expect("a frame is drawn")
|
||||
}
|
||||
}
|
||||
|
||||
/// Most frames a test runs while it waits for the print: the window waits for the document to
|
||||
/// settle (by the real clock) before it renders a print of a changed document.
|
||||
const SETTLE_FRAMES: usize = 200;
|
||||
|
||||
/// Whether the print shown is the one of the document and Show Fold Lines setting as they are.
|
||||
fn print_ready(app: &VectorcraftApp) -> bool {
|
||||
let view = &app.addon_panels.fold_view;
|
||||
let wanted = (app.session.active().map(|st| st.revision), app.ui.fold_preview.show_fold_lines);
|
||||
view.pending.is_none() && view.print.as_ref().map(|(k, _)| (Some(k.revision), k.fold_lines)) == Some(wanted)
|
||||
}
|
||||
|
||||
/// Lets a queued print finish, and gives the settle gate time to pass.
|
||||
fn wait_for_print(app: &VectorcraftApp) {
|
||||
if let Some(queue) = &app.addon_panels.fold_view.prints {
|
||||
queue.finish(PRINT_WAIT);
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
|
||||
/// Draws the window in a 520 × 440 room and settles it.
|
||||
fn drawn(app: &mut VectorcraftApp) -> Shown {
|
||||
Window::new(1.0, vec2(520.0, 440.0)).settle(app)
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -102,22 +138,22 @@ fn ui_fold_preview_sets_the_window_and_refuses_bad_values() {
|
||||
app.run("ui.foldPreview", json!({"rotateX": -30, "rotateY": 170, "base": null})).unwrap();
|
||||
assert_eq!((app.ui.fold_preview.rotate_x, app.ui.fold_preview.rotate_y, app.ui.fold_preview.base), (-30.0, 170.0, None));
|
||||
let kept = app.ui.fold_preview.clone();
|
||||
for (p, want) in [
|
||||
(json!({"amount": 2}), "`amount` must be a number from 0 to 1"),
|
||||
(json!({"amount": "half"}), "`amount` must be a number from 0 to 1"),
|
||||
(json!({"view": "sideways"}), "`view` must be one of"),
|
||||
(json!({"rotateX": 200}), "`rotateX` must be a number from -180 to 180"),
|
||||
(json!({"zoom": 0}), "`zoom` must be a number from 0.1 to 8"),
|
||||
(json!({"perspective": 170}), "`perspective` must be a number from 0 to 160"),
|
||||
(json!({"inside": "no such swatch"}), "`inside` must be #rrggbb"),
|
||||
(json!({"inside": 7}), "`inside` must be #rrggbb"),
|
||||
(json!({"showFoldLines": "yes"}), "`showFoldLines` must be true or false"),
|
||||
(json!({"base": [1, "2"]}), "`base` must be a point"),
|
||||
(json!({"base": [5, 5]}), "`base` is in no panel"),
|
||||
(json!({"amount": 0.2, "zoom": 99}), "`zoom` must be a number"),
|
||||
for p in [
|
||||
json!({"amount": 2}),
|
||||
json!({"amount": "half"}),
|
||||
json!({"view": "sideways"}),
|
||||
json!({"rotateX": 200}),
|
||||
json!({"zoom": 0}),
|
||||
json!({"perspective": 170}),
|
||||
json!({"inside": "no such swatch"}),
|
||||
json!({"inside": 7}),
|
||||
json!({"showFoldLines": "yes"}),
|
||||
json!({"base": [1, "2"]}),
|
||||
json!({"base": [5, 5]}),
|
||||
// A good value before a bad one sets nothing either.
|
||||
json!({"amount": 0.2, "zoom": 99}),
|
||||
] {
|
||||
let e = app.run("ui.foldPreview", p.clone()).unwrap_err().to_string();
|
||||
assert!(e.contains(want), "{p}: {e}");
|
||||
assert!(app.run("ui.foldPreview", p.clone()).is_err(), "{p} is refused");
|
||||
assert_eq!(app.ui.fold_preview, kept, "{p} sets nothing");
|
||||
}
|
||||
// A swatch with a plain color names the inside.
|
||||
@@ -144,42 +180,40 @@ fn ui_fold_preview_sets_the_window_and_refuses_bad_values() {
|
||||
#[test]
|
||||
fn the_window_draws_the_print_on_the_folded_panels_and_the_inside_on_their_backs() {
|
||||
let (mut app, _) = app();
|
||||
let mut window = Window::new(1.0, vec2(520.0, 440.0));
|
||||
// Flat, from the front: the base's print, red, fills the middle.
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
let before = prints_rendered();
|
||||
frame(&mut app);
|
||||
assert!(prints_rendered() > before, "the print is rendered on this thread without a worker");
|
||||
let img = last_image().expect("a frame");
|
||||
let [r, g, b, a] = middle(&img);
|
||||
let [r, g, b, a] = middle(&window.settle(&mut app).image);
|
||||
assert!(r > 150 && g < 40 && b < 40 && a == 255, "red print: {:?}", [r, g, b, a]);
|
||||
let state = app.run("ui.foldPreview", json!({})).unwrap();
|
||||
let img = app.addon_panels.fold_view.shown.clone().expect("a frame").image;
|
||||
assert_eq!((state["frame"]["width"].as_u64(), state["frame"]["height"].as_u64()), (Some(u64::from(img.width)), Some(u64::from(img.height))));
|
||||
// From the back, the base's inside shows in the inside color.
|
||||
app.run("ui.foldPreview", json!({"view": "back", "inside": "#00ff00"})).unwrap();
|
||||
frame(&mut app);
|
||||
let [r, g, b, _] = middle(&last_image().expect("a frame"));
|
||||
let [r, g, b, _] = middle(&window.settle(&mut app).image);
|
||||
assert!(r < 40 && g > 150 && b < 40, "green inside: {:?}", [r, g, b]);
|
||||
// Folded and seen from the front, the walls stand edge on: the base fills the same place.
|
||||
app.run("ui.foldPreview", json!({"amount": 1, "view": "front"})).unwrap();
|
||||
frame(&mut app);
|
||||
let img = last_image().expect("a frame");
|
||||
let [r, ..] = middle(&img);
|
||||
assert!(r > 150, "the base still shows its print: {:?}", middle(&img));
|
||||
let img = window.settle(&mut app).image;
|
||||
assert!(middle(&img)[0] > 150, "the base still shows its print: {:?}", middle(&img));
|
||||
// The same print is not rendered again while the document does not change.
|
||||
let prints = prints_rendered();
|
||||
frame(&mut app);
|
||||
assert_eq!(prints_rendered(), prints);
|
||||
let before = app.addon_panels.fold_view.print.clone();
|
||||
window.frame(&mut app);
|
||||
window.frame(&mut app);
|
||||
let after = app.addon_panels.fold_view.print.clone();
|
||||
let same = matches!((&before, &after), (Some((k, p)), Some((k2, p2))) if k == k2 && Arc::ptr_eq(p, p2));
|
||||
assert!(same, "no new print without a change");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_wide_perspective_still_fits_the_whole_folded_blank_in_the_view() {
|
||||
let (mut app, _) = app();
|
||||
let mut window = Window::new(1.0, vec2(520.0, 440.0));
|
||||
// Without perspective, the base and the two walls behind it that face the viewer show.
|
||||
let mut flat = None;
|
||||
for perspective in [0, 60, 160] {
|
||||
app.run("ui.foldPreview", json!({"amount": 1, "view": "threeQuarter", "zoom": 1, "perspective": perspective})).unwrap();
|
||||
frame(&mut app);
|
||||
let img = last_image().expect("a frame");
|
||||
let img = window.settle(&mut app).image;
|
||||
let mut shown: Vec<usize> =
|
||||
(0..img.height).flat_map(|y| (0..img.width).map(move |x| (x, y))).filter_map(|(x, y)| img.panel_at(x, y)).collect();
|
||||
shown.sort_unstable();
|
||||
@@ -196,12 +230,21 @@ fn a_wide_perspective_still_fits_the_whole_folded_blank_in_the_view() {
|
||||
fn a_window_with_more_pixels_than_the_view_may_have_is_drawn_smaller() {
|
||||
let (mut app, _) = app();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
frame_at(&mut app, 8.0);
|
||||
let img = last_image().expect("a frame");
|
||||
assert!(u64::from(img.width) * u64::from(img.height) <= u64::from(vectorcraft_three_d::fold::raster::MAX_PIXELS), "{}×{}", img.width, img.height);
|
||||
let img = Window::new(8.0, vec2(520.0, 440.0)).settle(&mut app).image;
|
||||
assert!(u64::from(img.width) * u64::from(img.height) <= u64::from(MAX_PIXELS), "{}×{}", img.width, img.height);
|
||||
assert!(img.width > 1000, "still sharper than one pixel a point: {}", img.width);
|
||||
let [r, ..] = middle(&img);
|
||||
assert!(r > 150, "the base's print shows: {:?}", middle(&img));
|
||||
assert!(middle(&img)[0] > 150, "the base's print shows: {:?}", middle(&img));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_short_wide_window_keeps_its_proportions() {
|
||||
let (mut app, _) = app();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
let shown = Window::new(2.0, vec2(2200.0, 260.0)).settle(&mut app);
|
||||
let (img, rect) = (&shown.image, shown.rect);
|
||||
let (image, window) = (f64::from(img.width) / f64::from(img.height), f64::from(rect.width() / rect.height()));
|
||||
assert!(img.width <= MAX_SIDE, "{}", img.width);
|
||||
assert!((image - window).abs() / window < 0.02, "image {image}, window {window}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -217,26 +260,14 @@ fn the_print_leaves_out_the_fold_lines_unless_they_are_shown() {
|
||||
app.run("stroke.set", json!({ "weight": 20 })).unwrap();
|
||||
app.run("select.none", json!({})).unwrap();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front", "zoom": 1})).unwrap();
|
||||
frame(&mut app);
|
||||
let plain = middle(&last_image().expect("a frame"));
|
||||
let mut window = Window::new(1.0, vec2(520.0, 440.0));
|
||||
let plain = middle(&window.settle(&mut app).image);
|
||||
app.run("ui.foldPreview", json!({"showFoldLines": true})).unwrap();
|
||||
frame(&mut app);
|
||||
let lined = middle(&last_image().expect("a frame"));
|
||||
let lined = middle(&window.settle(&mut app).image);
|
||||
assert_ne!(plain, lined, "the crease shows only with Show Fold Lines on");
|
||||
assert!(plain[0] > 200 && plain[1] > 200 && plain[2] > 200, "the board is white where the print has no art: {plain:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_window_says_when_there_is_nothing_to_fold() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
|
||||
let text = crate::tests_labels::painted_text(&mut app, show);
|
||||
assert!(text.contains("Check the fold lines first."), "{text}");
|
||||
let mut none = VectorcraftApp::new(Session::new(), Default::default());
|
||||
let text = crate::tests_labels::painted_text(&mut none, show);
|
||||
assert!(text.contains("Open a document to preview its folded shape."), "{text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_settings_are_kept_with_the_ui_state() {
|
||||
let (mut app, _) = app();
|
||||
@@ -260,192 +291,203 @@ fn saved_settings_out_of_range_are_brought_into_range() {
|
||||
base: Some([f64::INFINITY, 0.0]),
|
||||
..Settings::default()
|
||||
};
|
||||
frame(&mut app);
|
||||
let shown = drawn(&mut app);
|
||||
let set = &app.ui.fold_preview;
|
||||
assert_eq!(
|
||||
(set.amount, set.rotate_x, set.rotate_y, set.zoom, set.pan, set.perspective, set.base),
|
||||
(1.0, -160.0, 180.0, 0.1, [0.0, 4.0], 0.0, None)
|
||||
);
|
||||
let text = crate::tests_labels::painted_text(&mut app, show);
|
||||
assert!(!text.contains("Check the fold lines first."), "the blank folds: {text}");
|
||||
assert!(last_image().is_some(), "and is drawn");
|
||||
assert!(shown.image.width > 0, "the blank folds and is drawn");
|
||||
}
|
||||
|
||||
/// A window kept open over frames, as the app draws it.
|
||||
struct View {
|
||||
ctx: egui::Context,
|
||||
time: f64,
|
||||
/// The app showing the tray flat from the front, in a [`Fixture`] 520 × 440 points big.
|
||||
struct Rig {
|
||||
app: Rc<RefCell<VectorcraftApp>>,
|
||||
fx: Fixture,
|
||||
}
|
||||
|
||||
impl View {
|
||||
fn new(app: &mut VectorcraftApp) -> Self {
|
||||
impl Rig {
|
||||
fn front() -> Self {
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let ctx = egui::Context::default();
|
||||
crate::theme::install_fonts(&ctx);
|
||||
let mut v = View { ctx, time: 0.0 };
|
||||
v.idle(app);
|
||||
v
|
||||
let (mut app, _) = app();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
let app = Rc::new(RefCell::new(app));
|
||||
let shared = Rc::clone(&app);
|
||||
let mut fx = Fixture::new(move |ui| show(&mut shared.borrow_mut(), ui));
|
||||
fx.room(vec2(520.0, 440.0));
|
||||
let mut rig = Rig { app, fx };
|
||||
rig.settle();
|
||||
rig
|
||||
}
|
||||
|
||||
fn step(&mut self, app: &mut VectorcraftApp, events: Vec<Event>, modifiers: Modifiers) {
|
||||
self.time += 0.05;
|
||||
let screen = egui::Rect::from_min_size(Pos2::ZERO, vec2(520.0, 440.0));
|
||||
let events = std::iter::once(Event::ModifiersChanged(modifiers)).chain(events).collect();
|
||||
let input = egui::RawInput { time: Some(self.time), screen_rect: Some(screen), events, ..Default::default() };
|
||||
let mut out = self.ctx.run_ui(input, |ui| show(app, ui));
|
||||
out.textures_delta.clear();
|
||||
}
|
||||
|
||||
fn idle(&mut self, app: &mut VectorcraftApp) {
|
||||
for _ in 0..3 {
|
||||
self.step(app, vec![], Modifiers::NONE);
|
||||
/// Frames until the print of the document as it is has been rendered and drawn.
|
||||
fn settle(&mut self) {
|
||||
for _ in 0..SETTLE_FRAMES {
|
||||
self.fx.idle(1);
|
||||
if print_ready(&self.app.borrow()) {
|
||||
break;
|
||||
}
|
||||
wait_for_print(&self.app.borrow());
|
||||
}
|
||||
assert!(print_ready(&self.app.borrow()), "the print renders");
|
||||
self.fx.idle(3);
|
||||
}
|
||||
|
||||
/// Presses `button` at `at`, drags by `by` in four steps and lets go, holding `modifiers`.
|
||||
fn drag(&mut self, app: &mut VectorcraftApp, at: Pos2, by: egui::Vec2, button: PointerButton, modifiers: Modifiers) {
|
||||
let press = |pos, pressed| Event::PointerButton { pos, button, pressed, modifiers };
|
||||
self.step(app, vec![Event::PointerMoved(at)], modifiers);
|
||||
self.step(app, vec![press(at, true)], modifiers);
|
||||
fn settings(&self) -> Settings {
|
||||
self.app.borrow().ui.fold_preview.clone()
|
||||
}
|
||||
|
||||
/// The middle of the view's last image on screen.
|
||||
fn center(&self) -> Pos2 {
|
||||
self.app.borrow().addon_panels.fold_view.shown.as_ref().expect("the view is drawn").rect.center()
|
||||
}
|
||||
|
||||
fn run(&mut self, command: &str, params: Value) {
|
||||
self.app.borrow_mut().run(command, params).unwrap();
|
||||
}
|
||||
|
||||
/// Presses `button` at `at`, moves by `by` in four steps and lets go.
|
||||
fn drag_with(&mut self, button: PointerButton, at: Pos2, by: Vec2) {
|
||||
let mods = Modifiers::NONE;
|
||||
let event = |pos, pressed| Event::PointerButton { pos, button, pressed, modifiers: mods };
|
||||
self.fx.frame(vec![Event::PointerMoved(at)]);
|
||||
self.fx.frame(vec![event(at, true)]);
|
||||
for k in 1..=4 {
|
||||
self.step(app, vec![Event::PointerMoved(at + by * (k as f32 / 4.0))], modifiers);
|
||||
self.fx.frame(vec![Event::PointerMoved(at + by * (k as f32 / 4.0))]);
|
||||
}
|
||||
self.step(app, vec![press(at + by, false)], modifiers);
|
||||
self.idle(app);
|
||||
self.fx.frame(vec![event(at + by, false)]);
|
||||
self.fx.idle(3);
|
||||
}
|
||||
|
||||
fn click(&mut self, app: &mut VectorcraftApp, at: Pos2) {
|
||||
let press = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
|
||||
self.step(app, vec![Event::PointerMoved(at)], Modifiers::NONE);
|
||||
self.step(app, vec![press(true)], Modifiers::NONE);
|
||||
self.step(app, vec![press(false)], Modifiers::NONE);
|
||||
}
|
||||
|
||||
fn key(&mut self, app: &mut VectorcraftApp, key: egui::Key) {
|
||||
let press = Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
|
||||
self.step(app, vec![press], Modifiers::NONE);
|
||||
self.step(app, vec![], Modifiers::NONE);
|
||||
/// A key event with no modifiers, as the keyboard reports a press or a release.
|
||||
fn key_event(key: Key, pressed: bool) -> Event {
|
||||
Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE }
|
||||
}
|
||||
}
|
||||
|
||||
/// The app showing the tray flat from the front, in a [`View`], and the middle of the view.
|
||||
fn front_view() -> (VectorcraftApp, View, Pos2) {
|
||||
let (mut app, _) = app();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
let view = View::new(&mut app);
|
||||
let at = last_rect().expect("the view is drawn").center();
|
||||
(app, view, at)
|
||||
/// One way of working the view with the pointer, the wheel or the keys.
|
||||
enum Gesture {
|
||||
Drag(Vec2),
|
||||
ShiftDrag(Vec2),
|
||||
MiddleDrag(Vec2),
|
||||
SpaceDrag(Vec2),
|
||||
Wheel(f32),
|
||||
Arrows(&'static [Key]),
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_drag_turns_the_view_and_a_shift_drag_keeps_to_one_axis() {
|
||||
let (mut app, mut view, at) = front_view();
|
||||
view.drag(&mut app, at, vec2(40.0, 20.0), PointerButton::Primary, Modifiers::NONE);
|
||||
let set = app.ui.fold_preview.clone();
|
||||
assert!(set.rotate_y > 5.0 && set.rotate_y <= 20.0 + 1e-9, "{set:?}");
|
||||
assert!(set.rotate_x > 2.0 && set.rotate_x <= 10.0 + 1e-9, "{set:?}");
|
||||
app.run("ui.foldPreview", json!({"view": "front"})).unwrap();
|
||||
view.drag(&mut app, at, vec2(40.0, 20.0), PointerButton::Primary, Modifiers::SHIFT);
|
||||
let set = app.ui.fold_preview.clone();
|
||||
assert!(set.rotate_y > 5.0 && set.rotate_x == 0.0, "only the larger move turns the view: {set:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_middle_drag_moves_the_view_and_the_wheel_zooms_it() {
|
||||
let (mut app, mut view, at) = front_view();
|
||||
view.drag(&mut app, at, vec2(30.0, -10.0), PointerButton::Middle, Modifiers::NONE);
|
||||
let set = app.ui.fold_preview.clone();
|
||||
assert!(set.pan[0] > 0.0 && set.pan[1] < 0.0, "{set:?}");
|
||||
assert_eq!((set.rotate_x, set.rotate_y), (0.0, 0.0), "the view does not turn");
|
||||
let wheel = Event::MouseWheel {
|
||||
unit: egui::MouseWheelUnit::Point,
|
||||
delta: vec2(0.0, 60.0),
|
||||
phase: egui::TouchPhase::Move,
|
||||
modifiers: Modifiers::NONE,
|
||||
source: egui::MouseWheelSource::Unknown,
|
||||
};
|
||||
view.step(&mut app, vec![Event::PointerMoved(at), wheel], Modifiers::NONE);
|
||||
for _ in 0..20 {
|
||||
view.step(&mut app, vec![], Modifiers::NONE);
|
||||
fn the_view_gestures_change_the_settings() {
|
||||
let rows: [(Gesture, fn(&Settings) -> bool, &str); 7] = [
|
||||
(Gesture::Drag(vec2(40.0, 20.0)), |s| s.rotate_y > 5.0 && s.rotate_y <= 20.0 + 1e-9 && s.rotate_x > 2.0 && s.rotate_x <= 10.0 + 1e-9, "a drag turns"),
|
||||
(Gesture::ShiftDrag(vec2(40.0, 20.0)), |s| s.rotate_y > 5.0 && s.rotate_x == 0.0, "Shift keeps to the larger axis"),
|
||||
(
|
||||
Gesture::MiddleDrag(vec2(30.0, -10.0)),
|
||||
|s| s.pan[0] > 0.0 && s.pan[1] < 0.0 && (s.rotate_x, s.rotate_y) == (0.0, 0.0),
|
||||
"a middle drag moves and does not turn",
|
||||
),
|
||||
(
|
||||
Gesture::SpaceDrag(vec2(30.0, -10.0)),
|
||||
|s| s.pan[0] > 0.0 && s.pan[1] < 0.0 && (s.rotate_x, s.rotate_y) == (0.0, 0.0),
|
||||
"a drag with Space held moves and does not turn",
|
||||
),
|
||||
(Gesture::Wheel(60.0), |s| s.zoom > 1.05, "the wheel up zooms in"),
|
||||
(Gesture::Wheel(-60.0), |s| s.zoom < 0.95, "the wheel down zooms out"),
|
||||
(Gesture::Arrows(&[Key::ArrowUp, Key::ArrowRight, Key::ArrowRight]), |s| (s.rotate_x, s.rotate_y) == (-5.0, 10.0), "each press turns by 5°"),
|
||||
];
|
||||
for (gesture, holds, why) in rows {
|
||||
let mut rig = Rig::front();
|
||||
let at = rig.center();
|
||||
match gesture {
|
||||
Gesture::Drag(by) => rig.drag_with(PointerButton::Primary, at, by),
|
||||
Gesture::ShiftDrag(by) => {
|
||||
rig.fx.hold(Modifiers::SHIFT);
|
||||
rig.fx.drag_at(at, by);
|
||||
rig.fx.hold(Modifiers::NONE);
|
||||
}
|
||||
Gesture::MiddleDrag(by) => rig.drag_with(PointerButton::Middle, at, by),
|
||||
Gesture::SpaceDrag(by) => {
|
||||
rig.fx.frame(vec![Rig::key_event(Key::Space, true)]);
|
||||
rig.drag_with(PointerButton::Primary, at, by);
|
||||
rig.fx.frame(vec![Rig::key_event(Key::Space, false)]);
|
||||
}
|
||||
Gesture::Wheel(dy) => {
|
||||
let wheel = Event::MouseWheel {
|
||||
unit: craft::egui::MouseWheelUnit::Point,
|
||||
delta: vec2(0.0, dy),
|
||||
phase: craft::egui::TouchPhase::Move,
|
||||
modifiers: Modifiers::NONE,
|
||||
source: craft::egui::MouseWheelSource::Unknown,
|
||||
};
|
||||
rig.fx.frame(vec![Event::PointerMoved(at)]);
|
||||
rig.fx.frame(vec![wheel]);
|
||||
rig.fx.idle(20);
|
||||
}
|
||||
Gesture::Arrows(arrows) => {
|
||||
rig.fx.click_at(at);
|
||||
let focused = rig.fx.focused();
|
||||
assert!(focused.is_some(), "a click gives the view the focus");
|
||||
for key in arrows {
|
||||
rig.fx.key(*key, Modifiers::NONE);
|
||||
}
|
||||
assert_eq!(rig.fx.focused(), focused, "the arrows turn the view and leave the focus on it");
|
||||
}
|
||||
}
|
||||
assert!(holds(&rig.settings()), "{why}: {:?}", rig.settings());
|
||||
}
|
||||
assert!(app.ui.fold_preview.zoom > 1.05, "{:?}", app.ui.fold_preview);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_arrow_keys_turn_the_focused_view_and_keep_the_focus() {
|
||||
let (mut app, mut view, at) = front_view();
|
||||
view.click(&mut app, at);
|
||||
view.idle(&mut app);
|
||||
// Up first: the toolbar is above the view, where the focus would go if the view let it.
|
||||
view.key(&mut app, egui::Key::ArrowUp);
|
||||
view.key(&mut app, egui::Key::ArrowRight);
|
||||
view.key(&mut app, egui::Key::ArrowRight);
|
||||
let set = &app.ui.fold_preview;
|
||||
assert_eq!((set.rotate_x, set.rotate_y), (-5.0, 10.0), "every press turns the view by 5°");
|
||||
// A focused view seen from the back stays there until a key turns it.
|
||||
app.run("ui.foldPreview", json!({"view": "back"})).unwrap();
|
||||
view.idle(&mut app);
|
||||
assert_eq!(app.ui.fold_preview.rotate_y, 180.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_double_click_on_a_panel_makes_it_the_base() {
|
||||
let (mut app, mut view, at) = front_view();
|
||||
let mut rig = Rig::front();
|
||||
// The left wall is the base; the middle of the view shows the tray's base panel.
|
||||
app.run("ui.foldPreview", json!({"base": [120, 190]})).unwrap();
|
||||
view.idle(&mut app);
|
||||
view.click(&mut app, at);
|
||||
view.click(&mut app, at);
|
||||
let [x, y] = app.ui.fold_preview.base.expect("a base");
|
||||
rig.run("ui.foldPreview", json!({"base": [120, 190]}));
|
||||
rig.fx.idle(3);
|
||||
let at = rig.center();
|
||||
rig.fx.click_at(at);
|
||||
rig.fx.click_at(at);
|
||||
let [x, y] = rig.settings().base.expect("a base");
|
||||
assert!((140.0..240.0).contains(&x) && (140.0..240.0).contains(&y), "the base panel is picked: {x}, {y}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_double_click_as_the_document_changes_picks_nothing_from_the_old_image() {
|
||||
let (mut app, mut view, at) = front_view();
|
||||
app.run("ui.foldPreview", json!({"base": [120, 190]})).unwrap();
|
||||
view.idle(&mut app);
|
||||
view.click(&mut app, at);
|
||||
let mut rig = Rig::front();
|
||||
rig.run("ui.foldPreview", json!({"base": [120, 190]}));
|
||||
rig.fx.idle(3);
|
||||
let at = rig.center();
|
||||
rig.fx.click_at(at);
|
||||
let press = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
|
||||
view.step(&mut app, vec![press(true)], Modifiers::NONE);
|
||||
rig.fx.frame(vec![press(true)]);
|
||||
// The document changes between the image on screen and the release that ends the double-click.
|
||||
app.run("shape.rectangle", json!({"x": 350, "y": 350, "width": 10, "height": 10})).unwrap();
|
||||
view.step(&mut app, vec![press(false)], Modifiers::NONE);
|
||||
assert_eq!(app.ui.fold_preview.base, Some([120.0, 190.0]), "the base is kept");
|
||||
rig.run("shape.rectangle", json!({"x": 350, "y": 350, "width": 10, "height": 10}));
|
||||
rig.fx.frame(vec![press(false)]);
|
||||
assert_eq!(rig.settings().base, Some([120.0, 190.0]), "the base is kept");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_view_is_folded_and_drawn_again_only_when_something_changes() {
|
||||
let (mut app, mut view, _) = front_view();
|
||||
let (folds, renders) = work_done();
|
||||
view.idle(&mut app);
|
||||
assert_eq!(work_done(), (folds, renders), "nothing changed: no fold and no render");
|
||||
app.run("ui.foldPreview", json!({"rotateY": 10})).unwrap();
|
||||
view.idle(&mut app);
|
||||
assert_eq!(work_done(), (folds, renders + 1), "a turn renders once and does not fold again");
|
||||
app.run("ui.foldPreview", json!({"amount": 0.5})).unwrap();
|
||||
view.idle(&mut app);
|
||||
assert_eq!(work_done(), (folds + 1, renders + 2), "a new amount folds and renders once");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_short_wide_window_keeps_its_proportions() {
|
||||
let (mut app, _) = app();
|
||||
app.run("ui.foldPreview", json!({"amount": 0, "view": "front"})).unwrap();
|
||||
crate::i18n::set_current(crate::i18n::Lang::EN);
|
||||
let ctx = egui::Context::default();
|
||||
ctx.set_pixels_per_point(2.0);
|
||||
crate::theme::install_fonts(&ctx);
|
||||
for time in [0.0, 1.0] {
|
||||
let screen = egui::Rect::from_min_size(Pos2::ZERO, vec2(2200.0, 260.0));
|
||||
let input = egui::RawInput { time: Some(time), screen_rect: Some(screen), ..Default::default() };
|
||||
let mut out = ctx.run_ui(input, |ui| show(&mut app, ui));
|
||||
out.textures_delta.clear();
|
||||
}
|
||||
let (img, rect) = (last_image().expect("a frame"), last_rect().expect("a rect"));
|
||||
let (image, window) = (f64::from(img.width) / f64::from(img.height), f64::from(rect.width() / rect.height()));
|
||||
assert!(img.width <= vectorcraft_three_d::fold::raster::MAX_SIDE, "{}", img.width);
|
||||
assert!((image - window).abs() / window < 0.02, "image {image}, window {window}");
|
||||
let mut rig = Rig::front();
|
||||
let folded = |rig: &Rig| rig.app.borrow().addon_panels.fold_view.folded.as_ref().map(|f| Arc::clone(&f.1)).expect("a fold");
|
||||
let image = |rig: &Rig| rig.app.borrow().addon_panels.fold_view.shown.as_ref().map(|s| Arc::clone(&s.image)).expect("an image");
|
||||
// Frames one at a time, as the store counts the uploads of one frame.
|
||||
let uploads = |rig: &mut Rig| {
|
||||
(0..5)
|
||||
.map(|_| {
|
||||
rig.fx.frame(vec![]);
|
||||
store(rig.fx.ctx()).statistics(rig.fx.ctx()).uploads
|
||||
})
|
||||
.sum::<usize>()
|
||||
};
|
||||
let (fold, img) = (folded(&rig), image(&rig));
|
||||
assert_eq!(uploads(&mut rig), 0, "nothing changed: no render");
|
||||
assert!(Arc::ptr_eq(&fold, &folded(&rig)) && Arc::ptr_eq(&img, &image(&rig)), "and no new fold or image");
|
||||
rig.run("ui.foldPreview", json!({"rotateY": 10}));
|
||||
assert_eq!(uploads(&mut rig), 1, "a turn renders once");
|
||||
assert!(Arc::ptr_eq(&fold, &folded(&rig)), "and does not fold again");
|
||||
assert!(!Arc::ptr_eq(&img, &image(&rig)));
|
||||
rig.run("ui.foldPreview", json!({"amount": 0.5}));
|
||||
assert_eq!(uploads(&mut rig), 1, "a new amount renders once");
|
||||
assert!(!Arc::ptr_eq(&fold, &folded(&rig)), "and folds again");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -453,10 +495,10 @@ fn a_print_of_another_blank_or_setting_is_not_drawn_while_the_new_one_renders()
|
||||
let key = PrintKey { uid: 1, revision: 5, fold_lines: false, region: [0, 0, 10, 10], width: 1, height: 1 };
|
||||
let region = vectorcraft_geom::Rect::new(0.0, 0.0, 10.0, 10.0);
|
||||
let print = vectorcraft_three_d::fold::raster::Print::new(region, 1, 1, vec![255; 4]).expect("a print");
|
||||
let cache = Cache { print: Some((key, Arc::new(print))), ..Default::default() };
|
||||
assert!(cache.print_for(&PrintKey { revision: 6, ..key }).is_some(), "a newer revision of the same blank keeps the last print");
|
||||
let view = View { print: Some((key, Arc::new(print))), ..Default::default() };
|
||||
assert!(view.print_for(&PrintKey { revision: 6, ..key }).is_some(), "a newer revision of the same blank keeps the last print");
|
||||
for other in [PrintKey { uid: 2, ..key }, PrintKey { fold_lines: true, ..key }, PrintKey { region: [0, 0, 20, 10], ..key }] {
|
||||
assert!(cache.print_for(&other).is_none(), "{other:?}");
|
||||
assert!(view.print_for(&other).is_none(), "{other:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -471,35 +513,13 @@ fn the_status_line_reports_open_joints_crossing_panels_and_other_blanks() {
|
||||
hinges: vec![hinge(true, true, 0.0), hinge(false, false, 12.34), hinge(false, false, 3.0), hinge(false, true, 0.05)],
|
||||
collisions: vec![(0, 1)],
|
||||
};
|
||||
// The summary, the fold line errors, the other blanks, the open joint, the crossing panels.
|
||||
assert_eq!(status(3, Some((&Blank::default(), &f)), true).len(), 5);
|
||||
let lines = status(3, Some((&Blank::default(), &f)), true);
|
||||
assert_eq!(
|
||||
lines,
|
||||
[
|
||||
"Panels: 0, hinges: 0",
|
||||
"Check the fold lines first.",
|
||||
"Other blanks not shown: 2",
|
||||
"A joint does not close by 12.3 pt.",
|
||||
"Two panels pass through each other."
|
||||
]
|
||||
);
|
||||
assert_eq!(lines[1], status(0, None, false)[0], "the error line comes after the summary");
|
||||
// A joint that closes and panels that do not cross add nothing.
|
||||
let f = Folded { hinges: vec![hinge(false, true, 0.05)], collisions: vec![], ..f };
|
||||
assert_eq!(status(1, Some((&Blank::default(), &f)), false), ["Panels: 0, hinges: 0"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_window_says_when_folded_panels_pass_through_each_other() {
|
||||
// A strip: a 120 pt lid, a 30 pt wall, the 100 pt base and a 60 pt wall, all 50 pt deep. Folded
|
||||
// about the base, the lid crosses the taller wall.
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
|
||||
let path = |app: &mut VectorcraftApp, d: &str| app.run("path.create", json!({ "d": d })).unwrap()["id"].as_u64().unwrap();
|
||||
let outline = path(&mut app, "M0 0 L310 0 L310 50 L0 50 Z");
|
||||
let creases = [path(&mut app, "M120 0 L120 50"), path(&mut app, "M150 0 L150 50"), path(&mut app, "M250 0 L250 50")];
|
||||
app.run("addon.packaging.setRole", json!({ "role": "cut", "ids": [outline] })).unwrap();
|
||||
app.run("addon.packaging.setRole", json!({ "role": "crease", "ids": creases })).unwrap();
|
||||
app.run("select.none", json!({})).unwrap();
|
||||
app.run("ui.foldPreview", json!({"base": [200, 25], "amount": 1})).unwrap();
|
||||
let text = crate::tests_labels::painted_text(&mut app, show);
|
||||
assert!(text.contains("Two panels pass through each other."), "{text}");
|
||||
assert!(!text.contains("A joint does not close"), "{text}");
|
||||
assert_eq!(status(1, Some((&Blank::default(), &f)), false).len(), 1);
|
||||
// With no fold there is the one line that says why.
|
||||
assert_eq!(status(0, None, false).len(), 1);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user