iris-aiandClaude Opus 5
39e4ca20e6
`Px` and `PxVec2` reach the last places a pixel was a float: the window, the box a widget reads, the box it is compared against, and `PixelRegion`. A pointer, a wheel notch and a shaped glyph advance still arrive as floats, and each is put on the grid where it arrives. `Holds` is an interval of `Px`. `HOLDS_EPSILON_PX` is gone with the `exact`/tolerant split it existed for: `at` is the length a widget read, an open end is the next step along, and `same_px` is equality. `Span`'s margin from `5ed9e87` goes too -- the box a parent hands back and the sum of what its children asked for are counts of the same step, so the boundary decides the same way from either side. Three things had to be true for that, and were not: `Holds::through` inverts `px + rel * box`, which rounds -- so a part of a given length came from a range of boxes, and inverting the length alone gave a point that need not contain the box the part was drawn in. It now maps the half step either side, and one more for a length composed down the chain against the same length measured against the window. `RegionRemap` translates when a box only moved, rather than dividing to find each part's fraction and multiplying to place it again. Two roundings landed a step from where growing the tree that way does; a move is exact on a grid, which is the whole reason `tests/drift.rs` was written. A pixel is `1/1024` rather than `1/64`. At `1/64` the residue of a length reached two ways was one step, and one step was 0.016 px -- enough to move a box. `PX_SHIFT` and `REL_SHIFT` are the only statement of the grid now, and the shader's copy is prepended from them rather than written twice. Checked: fmt, clippy, 102 tests, 100 generated seeds in 75 s, all five shrinker cases at 300 seeds, and `tabs`, `view`, `minimal`, `text` and `random` byte-identical at 1920x1200. What the fuzzers ask for is now a step, not a twentieth of a pixel: the shrinker's five cases agree within one (`resize` exactly), and the oracle's two-operation cases within two. The residue is a single rounding either way -- it scales with the grid rather than accumulating, which is why it is a thousandth of a pixel now. Closing it means one way of asking how long a box is, rather than a chain composed down and a length measured against the window; that is a bigger change than this one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
140 lines
2.9 KiB
Rust
140 lines
2.9 KiB
Rust
use super::*;
|
|
use crate::{Fixed, FixedVec2};
|
|
|
|
#[derive(Copy, Clone, Debug, 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<const SHIFT: u32> FixedVec2<SHIFT> {
|
|
pub const fn axis(&self, axis: Axis) -> Fixed<SHIFT> {
|
|
match axis {
|
|
Axis::X => self.x,
|
|
Axis::Y => self.y,
|
|
}
|
|
}
|
|
|
|
pub const fn axis_mut(&mut self, axis: Axis) -> &mut Fixed<SHIFT> {
|
|
match axis {
|
|
Axis::X => &mut self.x,
|
|
Axis::Y => &mut self.y,
|
|
}
|
|
}
|
|
|
|
pub const fn from_axis(axis: Axis, aligned: Fixed<SHIFT>, ortho: Fixed<SHIFT>) -> Self {
|
|
match axis {
|
|
Axis::X => Self::new(aligned, ortho),
|
|
Axis::Y => Self::new(ortho, aligned),
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
const impl AxisT for XAxis {
|
|
fn get() -> Axis {
|
|
Axis::X
|
|
}
|
|
}
|
|
|
|
pub struct YAxis;
|
|
const impl AxisT for YAxis {
|
|
fn get() -> Axis {
|
|
Axis::Y
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default)]
|
|
pub struct BothAxis<T> {
|
|
pub x: T,
|
|
pub y: T,
|
|
}
|
|
|
|
impl<T> BothAxis<T> {
|
|
pub const fn axis<A: const AxisT>(&mut self) -> &mut T {
|
|
match A::get() {
|
|
Axis::X => &mut self.x,
|
|
Axis::Y => &mut self.y,
|
|
}
|
|
}
|
|
pub fn take_axis<A: const AxisT>(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,
|
|
}
|
|
}
|
|
}
|