#ifndef slic3r_DesignCanvas_hpp_ #define slic3r_DesignCanvas_hpp_ #include #include #include #include #include "3DBed.hpp" #include "libslic3r/Model.hpp" #include "libslic3r/SketchEngine.hpp" #include "DesignSketchTool.hpp" class wxGLCanvas; class wxFrame; class wxStaticText; namespace Slic3r { class TriangleMesh; namespace GUI { class GLCanvas3D; class SketchInlineEditor; class DesignCanvas : public wxPanel { public: explicit DesignCanvas(wxWindow* parent); ~DesignCanvas() override; void set_mesh(const TriangleMesh& mesh); // Multi-body display: one GLVolume per body, each coloured distinctly (per-body colour). // `visible` (optional, indexed by body) hides bodies whose flag is false. void set_bodies(const std::vector& body_meshes, const std::vector& visible = {}); void clear_mesh(); void set_preview_mesh(const TriangleMesh& mesh); void clear_preview(); void fit_view(); void set_view(const std::string& view_name); void begin_sketch(const SketchPlane& plane, DesignSketchTool::Mode mode); // Re-open a committed entity sketch for full in-canvas editing (load geometry + // constraints, re-detect feature groups). Re-commits via finish_sketch(). void edit_sketch(const std::vector& entities, const std::vector& constraints, const SketchPlane& plane); void set_sketch_tool(DesignSketchTool::Mode mode); void set_sketch_plane(const SketchPlane& plane); // re-plane the live sketch when the Plane dropdown changes void set_sketch_construction(bool c); void set_sketch_polygon_sides(int n); void set_sketch_polygon_circumscribed(bool c); void finish_sketch(); bool is_sketching() const; void refresh_bed(); // re-sync the bed to the current printer (call on tab activation) void cancel_sketch(); void set_on_sketch_commit(std::function cb); void set_on_sketch_entities_commit( std::function&, const std::vector&, const SketchPlane&)> cb); // Line tool: pending-segment length entry + live readout (Phase 2). void set_on_segment_drawn(std::function cb); void set_on_cursor_metrics(std::function cb); void set_on_solve_state(std::function cb); // dof, ok, has_constraints void apply_segment_length(double len); // exact length, then commit & repaint void keep_segment_as_drawn(); // commit as-drawn & repaint // Sketch selection (Mode::Select). void set_on_sketch_selection_changed(std::function cb); void set_on_sketch_face_selected(std::function cb); // closed loop clicked void set_on_display_sketch_selected(std::function cb); // committed loop clicked: (feature, region) std::vector selected_loop_entities() const; // entities of the click-selected loop std::vector> region_entity_indices(const std::vector& ents) const; void clear_loop_pick(); // drop the click-selected loop highlight (e.g. after extrude) // Solid whole/face/edge selection: point the tool at the bodies + concatenated // tessellation (with per-triangle face & body ids), and a callback fired on each // whole->face->edge cycle (level, body index, face id, edge id). void set_solid_pick(const std::vector* bodies, const TriangleMesh* mesh, const std::vector* tri_face, const std::vector* tri_body, const std::vector* visible = nullptr, const std::vector* xform = nullptr); void set_on_solid_selection_changed(std::function cb); void set_on_place_on_face(std::function cb); // F key: Place on Face void select_body(int body); // Parts-list -> highlight a whole body by index // Effective display colour of a body: the per-body override (Color tool) when set, // otherwise the auto body-index palette. Single source of truth shared with reload(). ColorRGBA body_color(int body) const; // Move-body gizmo (M5): three world-axis drag arrows on a body; drag fires the move // callback with the body index + accumulated translation (display-only, host applies it). // body_radius = bounding-sphere radius of the body in world mm; the gizmo scales with it so // the rotation rings sit OUTSIDE the solid (Orca's Prepare gizmos do the same). void begin_move_body(int body, const Vec3d& pivot, const Transform3d& base_xform, double body_radius); void clear_move_gizmo(); bool moving_body() const; void set_on_body_move_changed(std::function cb); // Visual Fillet/Chamfer radius gizmo: when a solid edge is picked, anchor a radius arrow on // it; drag/edit fire the radius callback. Returns false if no edge is currently picked. bool begin_fillet_gizmo(const Vec3d& body_centroid, double radius); void clear_fillet_gizmo(); bool filleting() const; void set_on_fillet_radius_changed(std::function cb); // Visual Hole gizmo: the panel feeds the hole plane + position + diameter/depth/through while // its Hole card is open; drag/edit fire the hole callback (x, y, diameter, depth). void begin_hole_gizmo(const SketchPlane& plane, double x, double y, double diameter, double depth, bool through); void set_hole_face_bounds(bool has, double umin, double umax, double vmin, double vmax); void clear_hole_gizmo(); bool holing() const; void set_on_hole_changed(std::function cb); // Visual Thread gizmo: footprint circle + radius/length arrows + draggable centre. void begin_thread_gizmo(const SketchPlane& plane, double x, double y, double radius, double height); void clear_thread_gizmo(); bool threading() const; void set_on_thread_changed(std::function cb); // Visual Shell gizmo: inward thickness arrow at the picked open-face centroid. void begin_shell_gizmo(const Vec3d& face_centroid, const Vec3d& inward_dir, double thickness); void clear_shell_gizmo(); bool shelling() const; void set_on_shell_thickness_changed(std::function cb); // Visual Revolve angle-arc gizmo: the panel feeds the sketch plane + profile centroid + axis // (0=plane X, 1=plane Y) + angle + flip while its Revolve card is open; drag/edit fire the // angle callback. void begin_revolve_gizmo(const SketchPlane& plane, const Vec2d& centroid, int axis_sel, double angle, bool flip); void clear_revolve_gizmo(); bool revolving() const; void set_on_revolve_angle_changed(std::function cb); // Visual Draft angle-arc gizmo: the panel feeds the face centroid + face normal + angle while // its Draft card is open; drag/edit fire the angle callback. void set_draft_gizmo(const Vec3d& face_centroid, const Vec3d& face_normal, double angle); void clear_draft_gizmo(); bool drafting() const; void set_on_draft_angle_changed(std::function cb); // Visual Cut gizmo: plane-rectangle preview + draggable normal offset arrow while // the Cut card is open; drag fires the offset callback. void set_cut_gizmo(const SketchPlane& plane, double offset, const Vec3d& body_center, double half_extent); void clear_cut_gizmo(); bool cutting() const; void set_on_cut_offset_changed(std::function cb); // Visual Pattern gizmo: the panel feeds the (world XY) plane + target body centroid + mode + // count/dir/spacing/angle while its Pattern card is open; drag/edit fire the value callback. void begin_pattern_gizmo(const SketchPlane& plane, const Vec3d& body_centroid, bool circular, int count, int dir, double spacing, double angle); void clear_pattern_gizmo(); bool patterning() const; void set_on_pattern_changed(std::function cb); // Visual Extrude depth-arrow gizmo (C5b): the panel feeds the profile plane + centroid + // live depths/flags while its Extrude card is open; drag/edit fire the depth callback. void set_extrude_gizmo(const SketchPlane& plane, const Vec2d& centroid, double depth, double depth2, bool two_sided, bool flip); void clear_extrude_gizmo(); void set_on_extrude_depth_changed(std::function cb); void set_datum_gizmo(const SketchPlane& plane, double usize, double vsize, const Vec3d& base_origin, const Vec3d& base_normal, double offset, bool offset_on); // C3 resize handles + offset arrow void clear_datum_gizmo(); void set_on_datum_size_changed(std::function cb); void set_on_datum_offset_changed(std::function cb); void set_base_pick(std::vector planes, std::vector bases, std::vector labels = {}); // clickable labelled reference planes void clear_base_pick(); void set_on_datum_base_picked(std::function cb); void set_on_sketch_exit(std::function cb); // Esc -> exit the tool void set_on_undo_redo(std::function cb); // Ctrl+Z / Ctrl+Shift+Z // Persistently draw committed sketches (un-consumed ones stay visible). void set_display_sketches(std::vector ds); void set_highlight_sketches(std::vector> hl); void set_datum_planes(std::vector planes, std::vector sizes = {}); // draw datum/reference planes (u/v extents) void set_body_highlight(bool on); // tint the solid when its feature is tree-selected void set_operand_bodies(int target_body, int tool_body); // -1,-1 clears void set_body_translucent(bool on); // render the solid see-through (fillet/chamfer preview) void set_body_hidden(bool on); // preview-only: hide base bodies, show only the result ghost void set_on_move_exit(std::function cb); // right-click finished the move-body gizmo void delete_selected_sketch_entities(); bool inline_busy() const; // a sketch value field is open (guard keys) bool undo_last_sketch_entity(); // Ctrl+Z in a sketch: drop the last entity bool delete_selected_or_last_sketch_entity(); // Delete in a sketch: selected, else last void clear_sketch_selection(); // View toggles (keys P / A): origin planes, world axis triad. Each returns the new on/off // state so the caller can echo it in the status bar. bool toggle_planes(); bool toggle_axes(); // Section views (non-destructive): the panel owns the named "Section View N" list; the canvas // just applies/clears one horizontal clip at a time. model_mid_z() is the default cut height. void set_section_plane(bool on, double z, bool keep_upper = false); double model_mid_z() const; // Dimension tool: act on the current sketch selection. DesignSketchTool::DimType sketch_dimension_kind() const; double sketch_dimension_current() const; void apply_sketch_dimension(double v); // Open the in-canvas value editor at the cursor for a host-driven value (the // committed-feature Constrain path uses this instead of a docked numeric card). void open_inline_value(double current, std::function commit, std::function cancel = {}); // Dimension tool (Mode::Dimension): click-to-place quotes. The pick-complete // callback lets the panel pop the value card; set/cancel apply or keep the value. void set_on_dimension_pick_complete(std::function cb); DesignSketchTool::DimType pending_dimension_type() const; void set_sketch_dimension_value(double v); void cancel_sketch_dimension(); // Constrain mode: load a committed profile for picking + constraint editing. void begin_constrain(const SketchProfile& prof, const SketchPlane& plane); // Leave constrain mode and clear any picked-entity highlight from the overlay. void end_constrain(); bool is_constraining() const; bool selected_segment(int& a, int& b) const; void update_constrain_profile(const std::vector& pts); // Entity-aware Constrain (Fase 4.2): pick Line entities of a committed sketch. void begin_constrain_entities(const std::vector& ents, const SketchPlane& plane); bool is_constraining_entities() const; // In-canvas bbox transform of imported Text/SVG art (replaces the Move/Scale dialog). void begin_imported_transform(int feat, const std::vector>>& base_regions, const SketchPlane& plane, const Vec2d& offset, double scale_x, double scale_y); void set_on_imported_transform(std::function cb); bool selected_constrain_entities(int& e0, int& e1) const; int selected_constrain_axis() const; // third pick slot (Symmetric axis), -1 if unset bool pick0_point(Vec2d& out) const; // plane-coords of the slot-0 pick (trim/extend) void update_constrain_entities(const std::vector& ents); // Constraint manager (C3.4): highlight the entities referenced by a selected // constraint (yellow tint in Constrain mode); empty clears the highlight. void set_constraint_highlight(std::vector entities); // Constraint glyph badges (C3.4b): the feature's constraints, drawn as iconic // marks near their entities in Constrain mode; empty clears them. void set_constraint_glyphs(std::vector cons); // Repaint the embedded canvas the right way for the active GL backend: // hardware GL gets a scheduled wxEVT_PAINT (render() runs inside the paint // cycle); software GL (llvmpipe etc.) gets a direct render() because a // scheduled Refresh() is frequently dropped there. Backend cached on first use. // Public: DesignPanel calls it after a tree edit to force a frame on software GL. void request_repaint(); // Repaint synchronously, once the pending show/resize has settled. Needed when the // notebook re-shows the Design page: an invalidation issued while the page is still // being shown is dropped on hardware GL and no wxEVT_PAINT ever follows, leaving the // canvas blank until another tab switch forces an expose. void force_repaint(); private: void reload(bool keep_view); wxGLCanvas* m_canvas_widget{nullptr}; GLCanvas3D* m_canvas{nullptr}; int m_sw_gl{-1}; // -1 unknown, 0 hardware GL, 1 software GL Bed3D m_bed; Model m_model; bool m_first_frame{true}; bool m_body_selected{false}; // tree selected a body feature → tint the solid int m_hl_body_target{-1}; int m_hl_body_tool{-1}; bool m_body_translucent{false};// fillet/chamfer preview → render the body see-through bool m_body_hidden{false}; // preview-only mode → hide base bodies, ghost = the result std::vector m_body_visible; // per-body visibility (empty => all visible) // Live pointer to the document's bodies (stable address: m_doc.bodies), stashed by // set_solid_pick so reload()/body_color() can read each body's colour override. const std::vector* m_color_bodies{nullptr}; DesignSketchTool m_sketch_tool; // Section view: whether a horizontal clip is currently applied (guards Alt+Wheel). The cut // height and the named-view list live in DesignPanel; the canvas is a dumb applier. bool m_section_on{false}; std::unique_ptr m_inline_editor; // floating in-canvas value editor // Bottom-right viewport HUD: a borderless float label over the GL canvas showing the // active tool's current values (fed by the tool's on_readout). Empty text hides it. wxFrame* m_hud{nullptr}; wxStaticText* m_hud_label{nullptr}; std::string m_hud_last; void set_readout(const std::string& text); std::function m_on_sketch_commit; std::function&, const std::vector&, const SketchPlane&)> m_on_sketch_entities_commit; }; }} // namespace Slic3r::GUI #endif // slic3r_DesignCanvas_hpp_