Lil improvements

Author: Tom

detailer/src/lib.rs

@@ -198,6 +198,11 @@ impl<'a> Widget<'a> {
             *changed |= ui
                 .add_sized([50., text_height * 1.4], egui::DragValue::new(d))
                 .changed();
+
+            if *changed && *d < 0. {
+                *d = 0.;
+            }
+
             ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
                 if ui.button("⊗").clicked() {
                     commands.push(ToolResponse::ConstraintDelete(*k));
@@ -229,9 +234,16 @@ impl<'a> Widget<'a> {
                 .rect;
             ui.add_space(r.x / 2. - text_rect.width() - ui.spacing().item_spacing.x);
 
-            // *changed |= ui
-            //     .add_sized([50., text_height * 1.4], egui::DragValue::new(d))
-            //     .changed();
+            let resp = ui.add_sized(
+                [100. + ui.spacing().item_spacing.x, text_height * 1.4],
+                egui::Button::new("swap direction"),
+            );
+
+            if resp.clicked() {
+                *changed |= true;
+                *is_horizontal = !*is_horizontal;
+            }
+
             ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
                 if ui.button("⊗").clicked() {
                     commands.push(ToolResponse::ConstraintDelete(*k));

drawing/src/data/mod.rs

@@ -94,7 +94,7 @@ impl Data {
                     if num_solutions == 1 {
                         let f = expr.evaluate(sub_solver_state, 0).unwrap().as_f64();
                         self.apply_solved(&term, f);
-                    } else if num_solutions < 8 {
+                    } else if num_solutions <= 32 {
                         let current = match self.term_current_value(&term) {
                             Some(f) => f as f64,
                             None => {
@@ -198,6 +198,10 @@ impl Data {
     }
 
     fn apply_solved(&mut self, term: &TermRef, v: f64) -> bool {
+        if v.is_nan() || v.is_infinite() {
+            return false;
+        }
+
         if let Some(feature) = term.for_feature {
             match self.features.get_mut(feature) {
                 Some(Feature::Point(_, x, y)) => {

drawing/src/l/draw.rs

@@ -92,12 +92,19 @@ impl<'a> DimensionLengthOverlay<'a> {
     }
 
     fn draw_stop_lines(&self, t: f32, sa: egui::Pos2, sb: egui::Pos2, painter: &egui::Painter) {
-        let l = self.reference.length();
+        let l = egui::Vec2::angled(std::f32::consts::PI / 2.).dot(self.reference);
+        let t = t - self.reference.angle() + std::f32::consts::PI / 2.;
+
+        let offset = if l >= 0. {
+            DimensionLengthOverlay::LINE_STOP_OFFSET
+        } else {
+            -DimensionLengthOverlay::LINE_STOP_OFFSET
+        };
 
         painter.line_segment(
             [
                 sa + egui::Vec2::angled(t) * l,
-                sa + egui::Vec2::angled(t) * DimensionLengthOverlay::LINE_STOP_OFFSET,
+                sa + egui::Vec2::angled(t) * offset,
             ],
             egui::Stroke {
                 width: 1.,
@@ -107,7 +114,7 @@ impl<'a> DimensionLengthOverlay<'a> {
         painter.line_segment(
             [
                 sb + egui::Vec2::angled(t) * l,
-                sb + egui::Vec2::angled(t) * DimensionLengthOverlay::LINE_STOP_OFFSET,
+                sb + egui::Vec2::angled(t) * offset,
             ],
             egui::Stroke {
                 width: 1.,

eq/src/solve.rs

@@ -202,7 +202,7 @@ impl SubSolver {
             if out.expr.num_solutions() == 1 {
                 let cc = out.expr.evaluate(st, 0).unwrap();
                 match cc {
-                    Concrete::Float(ref f) if !f.is_nan() => {
+                    Concrete::Float(ref f) if !f.is_nan() && !f.is_infinite() => {
                         st.resolved
                             .insert(var.clone(), SolvePlan::Concrete(cc.clone()));
                         return Ok(SolvePlan::Concrete(cc));
@@ -339,6 +339,8 @@ impl SubSolver {
                 }
             }
         }
+        // TODO: Sometimes the substitutions are such that there's a ton of possible solutions.
+        // Maybe we can try and find better substitutions in those cases?
 
         for v in vars {
             if let Some(p) = st.resolved.get(&v).clone() {