Cross Section Tool for Meshes

tests/render/002-mesh-surface-headless/main.cpp

@@ -248,3 +248,51 @@ TEST_CASE("Mesh Surface Selection")
             1.57079632679f);
     }
 }
+
+TEST_CASE("Mesh Surface Cross Section")
+{
+    SECTION("Vertex Cross Section")
+    {
+        runRenderTest(
+            TEST_NAME, "cross_section_vertex", [](vcl::HeadlessMeshViewer& mv) {
+                auto mesh = getDrawableMesh<vcl::TriMesh>("bimba.obj");
+
+                vcl::CrossSectionSettings css(mesh);
+                css.type() =
+                    vcl::CrossSectionSettings::CrossSectionType::PER_VERTEX;
+
+                vcl::Point3f min = css.boundingBox().min();
+                vcl::Point3f max = css.boundingBox().max();
+                css.setLowerUpper(
+                    min + (max - min) * 0.25f, max - (max - min) * 0.25f);
+
+                mesh.setCrossSectionSettings(css);
+
+                mv.pushDrawableObject(std::move(mesh));
+            });
+    }
+
+    SECTION("Fragment Cross Section")
+    {
+        runRenderTest(
+            TEST_NAME,
+            "cross_section_fragment",
+            [](vcl::HeadlessMeshViewer& mv) {
+                auto mesh = getDrawableMesh<vcl::TriMesh>("bimba.obj");
+
+                vcl::CrossSectionSettings css(mesh);
+                css.type() =
+                    vcl::CrossSectionSettings::CrossSectionType::PER_FRAGMENT;
+
+                vcl::Point3f min = css.boundingBox().min();
+                vcl::Point3f max = css.boundingBox().max();
+                css.setLowerUpper(
+                    min + (max - min) * 0.25f, max - (max - min) * 0.25f);
+
+                mesh.setCrossSectionSettings(css);
+
+                mv.pushDrawableObject(std::move(mesh));
+            });
+    }
+}
+

tests/render/005-mesh-wireframe-headless/main.cpp

@@ -208,3 +208,74 @@ TEST_CASE("Wireframe Depth Offset")
             -150.f);
     }
 }
+
+TEST_CASE("Wireframe Cross Section")
+{
+    SECTION("Vertex Cross Section")
+    {
+        runRenderTest(
+            TEST_NAME,
+            "cross_section_vertex",
+            [](vcl::HeadlessMeshViewer& mv) {
+                auto mesh =
+                    getDrawableMesh<vcl::TriMesh>("bunny_simplified.obj");
+
+                auto settings = mesh.renderSettings();
+                settings.setSurface(
+                    vcl::MeshRenderInfo::Surface::VISIBLE, false);
+                settings.setWireframe(
+                    vcl::MeshRenderInfo::Wireframe::VISIBLE, true);
+                settings.setWireframeWidth(3);
+                mesh.setRenderSettings(settings);
+
+                vcl::CrossSectionSettings css(mesh);
+                css.type() =
+                    vcl::CrossSectionSettings::CrossSectionType::PER_VERTEX;
+
+                vcl::Point3f min = css.boundingBox().min();
+                vcl::Point3f max = css.boundingBox().max();
+                css.setLowerUpper(
+                    min + (max - min) * 0.25f, max - (max - min) * 0.25f);
+
+                mesh.setCrossSectionSettings(css);
+
+                mv.pushDrawableObject(std::move(mesh));
+            },
+            0.f,
+            -150.f);
+    }
+
+    SECTION("Fragment Cross Section")
+    {
+        runRenderTest(
+            TEST_NAME,
+            "cross_section_fragment",
+            [](vcl::HeadlessMeshViewer& mv) {
+                auto mesh =
+                    getDrawableMesh<vcl::TriMesh>("bunny_simplified.obj");
+
+                auto settings = mesh.renderSettings();
+                settings.setSurface(
+                    vcl::MeshRenderInfo::Surface::VISIBLE, false);
+                settings.setWireframe(
+                    vcl::MeshRenderInfo::Wireframe::VISIBLE, true);
+                settings.setWireframeWidth(3);
+                mesh.setRenderSettings(settings);
+
+                vcl::CrossSectionSettings css(mesh);
+                css.type() =
+                    vcl::CrossSectionSettings::CrossSectionType::PER_FRAGMENT;
+
+                vcl::Point3f min = css.boundingBox().min();
+                vcl::Point3f max = css.boundingBox().max();
+                css.setLowerUpper(
+                    min + (max - min) * 0.25f, max - (max - min) * 0.25f);
+
+                mesh.setCrossSectionSettings(css);
+
+                mv.pushDrawableObject(std::move(mesh));
+            },
+            0.f,
+            -150.f);
+    }
+}

vclib/core/include/vclib/space/core/point.h

@@ -397,6 +397,70 @@ class Point : public Eigen::Matrix<Scalar, N, 1>
             at(i) = args[i];
     }
 
+    /**
+     * @brief Returns true if all the components of this point are strictly less
+     * than the corresponding components of another point p1.
+     *
+     * @param[in] p1: The Point object to compare with.
+     * @return true if this point is strictly below p1, false otherwise.
+     */
+    bool allLessThan(const Point& p1) const
+    {
+        for (uint i = 0; i < N; i++) {
+            if (at(i) >= p1(i))
+                return false;
+        }
+        return true;
+    }
+
+    /**
+     * @brief Returns true if all the components of this point are less than or
+     * equal to the corresponding components of another point p1.
+     *
+     * @param[in] p1: The Point object to compare with.
+     * @return true if this point is below or equal to p1, false otherwise.
+     */
+    bool allLessEqualThan(const Point& p1) const
+    {
+        for (uint i = 0; i < N; i++) {
+            if (at(i) > p1(i))
+                return false;
+        }
+        return true;
+    }
+
+    /**
+     * @brief Returns true if all the components of this point are strictly
+     * greater than the corresponding components of another point p1.
+     *
+     * @param[in] p1: The Point object to compare with.
+     * @return true if this point is strictly above p1, false otherwise.
+     */
+    bool allGreaterThan(const Point& p1) const
+    {
+        for (uint i = 0; i < N; i++) {
+            if (at(i) <= p1(i))
+                return false;
+        }
+        return true;
+    }
+
+    /**
+     * @brief Returns true if all the components of this point are greater than
+     * or equal to the corresponding components of another point p1.
+     *
+     * @param[in] p1: The Point object to compare with.
+     * @return true if this point is above or equal to p1, false otherwise.
+     */
+    bool allGreaterEqualThan(const Point& p1) const
+    {
+        for (uint i = 0; i < N; i++) {
+            if (at(i) < p1(i))
+                return false;
+        }
+        return true;
+    }
+
     /**
      * @brief Returns the outer product between this point p and p1, which is
      * p * p1^T

vclib/render/include/vclib/bgfx/drawable/drawable_mesh_bgfx.h

@@ -16,6 +16,7 @@
 #include <vclib/bgfx/context.h>
 #include <vclib/bgfx/drawable/drawable_environment.h>
 #include <vclib/bgfx/drawable/mesh/mesh_render_buffers.h>
+#include <vclib/bgfx/drawable/uniforms/cross_section_uniforms.h>
 #include <vclib/bgfx/drawable/uniforms/mesh_render_settings_uniforms.h>
 
 #include <bgfx/bgfx.h>
@@ -94,6 +95,9 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         mMRB.update(*this, buffersToUpdate);
         mMRS.setRenderCapabilityFrom(*this);
         setRenderSettings(mMRS);
+
+        mCSS.setBoundingBox(*this);
+        mMRB.updateCrossSectionSettings(mCSS);
     }
 
     void updateRenderSettingsCapabilities() override
@@ -109,6 +113,12 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         mMRB.updatePointsSettings(rs);
     }
 
+    void setCrossSectionSettings(const CrossSectionSettings& css) override
+    {
+        AbstractDrawableMesh::setCrossSectionSettings(css);
+        mMRB.updateCrossSectionSettings(css);
+    }
+
     const AbstractMeshProvider& meshProvider() const override
     {
         return mProvider;
@@ -205,6 +215,8 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         DrawableMeshUniforms::setColor(*this);
         MeshRenderSettingsUniforms::set(mMRS);
 
+        updateCrossSectionUniforms();
+
         if (mMRS.isSurface(MRI::Surface::VISIBLE)) {
             const DrawableEnvironment* env = settings.environment;
 
@@ -314,6 +326,8 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
             model = MeshType::transformMatrix().template cast<float>();
         }
 
+        updateCrossSectionUniforms();
+
         if (mMRS.isSurface(MRI::Surface::VISIBLE)) {
             mMRB.bindVertexBuffers(mMRS);
             mMRB.bindIndexBuffers(mMRS);
@@ -349,6 +363,21 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
     {
         MeshRenderSettingsUniforms::bind();
         DrawableMeshUniforms::bind();
+        CrossSectionUniforms::bind();
+    }
+
+    void updateCrossSectionUniforms() const
+    {
+        if (AbstractDrawableMesh::mCSS.isEnabled()) {
+            using enum CrossSectionSettings::CrossSectionType;
+            CrossSectionUniforms::set(
+                AbstractDrawableMesh::mCSS.lower(),
+                AbstractDrawableMesh::mCSS.upper(),
+                AbstractDrawableMesh::mCSS.type() == PER_FRAGMENT);
+        }
+        else {
+            CrossSectionUniforms::set();
+        }
     }
 
     /**
@@ -400,12 +429,17 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
     {
         using enum MeshRenderInfo::Surface;
 
+        uint section   = 0;
         uint shading   = 0;
         uint color     = 0;
         uint selection = 0;
         uint backFace  = 0;
         uint specular  = 0;
 
+        if (!mCSS.isEnabled()) {
+            section = 1;
+        }
+
         if (mMRS.isSurface(SHADING_FLAT)) {
             shading = 0;
         }
@@ -455,18 +489,21 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         constexpr uint N_SELECTION_MODES = 2;
         constexpr uint N_BACK_FACE_MODES = 2;
         constexpr uint N_SPECULAR_MODES  = 2;
+        constexpr uint N_SECTION_MODES   = 2;
 
         // the first shader of all the combinations
         uint base = toUnderlying(
             VertFragProgram::
-                DRAWABLE_MESH_SURFACE_SHADING_FLAT_COLOR_FACE_SELECTION_ON_BACK_FACE_DOUBLE_OFF_SPECULAR_OFF);
+                DRAWABLE_MESH_SURFACE_SECTION_ON_SHADING_FLAT_COLOR_FACE_SELECTION_ON_BACK_FACE_DOUBLE_OFF_SPECULAR_OFF);
 
         uint offset = linearizeIndex<
+            N_SECTION_MODES,
             N_SHADING_MODES,
             N_COLOR_MODES,
             N_SELECTION_MODES,
             N_BACK_FACE_MODES,
-            N_SPECULAR_MODES>(shading, color, selection, backFace, specular);
+            N_SPECULAR_MODES>(
+            section, shading, color, selection, backFace, specular);
 
         uint program = base + offset;
 

vclib/render/include/vclib/bgfx/drawable/mesh/mesh_render_buffers.h

@@ -426,6 +426,13 @@ class MeshRenderBuffers : public MeshRenderData<MeshRenderBuffers<Mesh>>
         mPoints.setSelectionColor(mrs.pointSelectionColor());
     }
 
+    void updateCrossSectionSettings(const CrossSectionSettings& css)
+    {
+        mEdgeLines.setCrossSectionSettings(css);
+        mWireframeLines.setCrossSectionSettings(css);
+        mPoints.setCrossSectionSettings(css);
+    }
+
 private:
     void setVertexPositionsBuffer(const MeshType& mesh) // override
     {