Modeling: mirror support for the hide operator

Use EditMeshSymmetryHelper so hiding operates on mirrored geometry.

Ref !142698

source/blender/editors/include/ED_mesh.hh

@@ -233,6 +233,14 @@ void ED_mesh_undosys_type(UndoType *ut);
 void EDBM_select_mirrored(
     BMEditMesh *em, const Mesh *mesh, int axis, bool extend, int *r_totmirr, int *r_totfail);
 
+/**
+ * Select mirrored elements on all enabled axis.
+ * Does nothing if selection symmetry isn't enabled.
+ *
+ * \return true if the selection changed.
+ */
+bool EDBM_select_mirrored_extend_all(Object *obedit, BMEditMesh *em);
+
 /**
  * Nearest vertex under the cursor.
  *

source/blender/editors/mesh/editmesh_select.cc

@@ -241,6 +241,101 @@ void EDBM_select_mirrored(BMEditMesh *em,
   *r_totfail = totfail;
 }
 
+bool EDBM_select_mirrored_extend_all(Object *obedit, BMEditMesh *em)
+{
+  BMesh *bm = em->bm;
+  int selectmode = em->selectmode;
+  bool changed = false;
+
+  if (bm->totfacesel == 0) {
+    selectmode &= ~SCE_SELECT_FACE;
+  }
+  if (bm->totedgesel == 0) {
+    selectmode &= ~SCE_SELECT_EDGE;
+  }
+  if (bm->totvertsel == 0) {
+    selectmode &= ~SCE_SELECT_VERTEX;
+  }
+
+  if (selectmode == 0) {
+    return changed;
+  }
+
+  char symmetry_htype = 0;
+  if (selectmode & SCE_SELECT_FACE) {
+    symmetry_htype |= BM_FACE;
+  }
+  if (selectmode & SCE_SELECT_EDGE) {
+    symmetry_htype |= BM_EDGE;
+  }
+  if (selectmode & SCE_SELECT_VERTEX) {
+    symmetry_htype |= BM_VERT;
+  }
+  if (std::optional<EditMeshSymmetryHelper> symmetry_helper =
+          EditMeshSymmetryHelper::create_if_needed(obedit, symmetry_htype))
+  {
+    const char hflag = BM_ELEM_SELECT;
+    BMIter iter;
+
+    if (selectmode & SCE_SELECT_FACE) {
+      blender::Vector<BMFace *> source_faces;
+      source_faces.reserve(bm->totfacesel);
+      BMFace *f;
+      BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
+        if (BM_elem_flag_test(f, hflag)) {
+          source_faces.append(f);
+        }
+      }
+      const int totfacesel_prev = bm->totfacesel;
+      for (BMFace *f_orig : source_faces) {
+        symmetry_helper->set_hflag_on_mirror_faces(f_orig, hflag, true);
+      }
+      if (bm->totfacesel != totfacesel_prev) {
+        changed = true;
+      }
+    }
+    if (selectmode & SCE_SELECT_EDGE) {
+      blender::Vector<BMEdge *> source_edges;
+      source_edges.reserve(bm->totedgesel);
+      BMEdge *e;
+      BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
+        if (BM_elem_flag_test(e, hflag)) {
+          source_edges.append(e);
+        }
+      }
+      const int totedgesel_prev = bm->totedgesel;
+      for (BMEdge *e_orig : source_edges) {
+        symmetry_helper->set_hflag_on_mirror_edges(e_orig, hflag, true);
+      }
+      if (bm->totedgesel != totedgesel_prev) {
+        changed = true;
+      }
+    }
+    if (selectmode & SCE_SELECT_VERTEX) {
+      blender::Vector<BMVert *> source_verts;
+      source_verts.reserve(bm->totvertsel);
+      BMVert *v;
+      BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
+        if (BM_elem_flag_test(v, hflag)) {
+          source_verts.append(v);
+        }
+      }
+      const int totvertsel_prev = bm->totvertsel;
+      for (BMVert *v_orig : source_verts) {
+        symmetry_helper->set_hflag_on_mirror_verts(v_orig, hflag, true);
+      }
+      if (bm->totvertsel != totvertsel_prev) {
+        changed = true;
+      }
+    }
+    if (changed) {
+      EDBM_selectmode_flush(em);
+    }
+  }
+
+  return changed;
+}
+
 /** \} */
 
 /* -------------------------------------------------------------------- */

source/blender/editors/mesh/editmesh_tools.cc

@@ -2469,6 +2469,9 @@ static wmOperatorStatus edbm_hide_exec(bContext *C, wmOperator *op)
       }
     }
 
+    /* Only if symmetry is enabled. */
+    EDBM_select_mirrored_extend_all(obedit, em);
+
     if (EDBM_mesh_hide(em, unselected)) {
       EDBMUpdate_Params params{};
       params.calc_looptris = true;