Cross Section Tool for Meshes

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

@@ -412,6 +412,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

@@ -29,6 +29,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>
@@ -137,6 +138,9 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         mMRB.update(*this, buffersToUpdate);
         mMRS.setRenderCapabilityFrom(*this);
         setRenderSettings(mMRS);
+
+        mCSS.setBoundingBox(*this);
+        mMRB.updateCrossSectionSettings(mCSS);
     }
 
     void setRenderSettings(const MeshRenderSettings& rs) override
@@ -146,6 +150,12 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         mMRB.updateWireframeSettings(rs);
     }
 
+    void setCrossSectionSettings(const CrossSectionSettings& css) override
+    {
+        AbstractDrawableMesh::setCrossSectionSettings(css);
+        mMRB.updateCrossSectionSettings(css);
+    }
+
     uint vertexCount() const override { return MeshType::vertexCount(); }
 
     uint faceCount() const override
@@ -216,6 +226,8 @@ class DrawableMeshBGFX : public AbstractDrawableMesh, public MeshType
         DrawableMeshUniforms::setColor(*this);
         MeshRenderSettingsUniforms::set(mMRS);
 
+        updateCrossSectionUniforms();
+
         if (mMRS.isSurface(MRI::Surface::VISIBLE)) {
             const PBRViewerSettings&   pbrSettings = settings.pbrSettings;
             const DrawableEnvironment* env         = settings.environment;
@@ -337,6 +349,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);
@@ -407,6 +421,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();
+        }
     }
 
     /**

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

@@ -326,6 +326,12 @@ class MeshRenderBuffers : public MeshRenderData<MeshRenderBuffers<Mesh>>
         }
     }
 
+    void updateCrossSectionSettings(const CrossSectionSettings& css)
+    {
+        mEdgeLines.crossSectionSettings() = css;
+        mWireframeLines.crossSectionSettings() = css;
+    }
+
 private:
     void setVertexPositionsBuffer(const MeshType& mesh) // override
     {

vclib/render/include/vclib/bgfx/drawable/uniforms/cross_section_uniforms.h

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * VCLib                                                                     *
+ * Visual Computing Library                                                  *
+ *                                                                           *
+ * Copyright(C) 2021-2026                                                    *
+ * Visual Computing Lab                                                      *
+ * ISTI - Italian National Research Council                                  *
+ *                                                                           *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This program is free software; you can redistribute it and/or modify      *
+ * it under the terms of the Mozilla Public License Version 2.0 as published *
+ * by the Mozilla Foundation; either version 2 of the License, or            *
+ * (at your option) any later version.                                       *
+ *                                                                           *
+ * This program is distributed in the hope that it will be useful,           *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
+ * Mozilla Public License Version 2.0                                        *
+ * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
+ ****************************************************************************/
+
+#ifndef VCL_BGFX_DRAWABLE_UNIFORMS_CROSS_SECTION_UNIFORMS_H
+#define VCL_BGFX_DRAWABLE_UNIFORMS_CROSS_SECTION_UNIFORMS_H
+
+#include <vclib/bgfx/uniform.h>
+
+#include <vclib/space/core.h>
+
+namespace vcl {
+
+class CrossSectionUniforms
+{
+    inline static std::array<float, 4> sCrossSectionMinData = {
+        Point3f::min().x(), // x min
+        Point3f::min().y(), // y min
+        Point3f::min().z(), // z min
+        0.0                 // per-fragment flag
+                            // (0.0 = per-vertex, 1.0 = per-fragment)
+    };
+
+    inline static std::array<float, 4> sCrossSectionMaxData = {
+        Point3f::max().x(), // x max
+        Point3f::max().y(), // y max
+        Point3f::max().z(), // z max
+        0.0                 // unused
+    };
+
+    inline static Uniform sCrossSectionMinDataUniform;
+    inline static Uniform sCrossSectionMaxDataUniform;
+
+public:
+    CrossSectionUniforms() = delete;
+
+    static void set(
+        const Point3f& minPoint    = Point3f::min(),
+        const Point3f& maxPoint    = Point3f::max(),
+        bool           perFragment = false)
+    {
+        sCrossSectionMinData[0] = minPoint.x();
+        sCrossSectionMinData[1] = minPoint.y();
+        sCrossSectionMinData[2] = minPoint.z();
+        sCrossSectionMinData[3] = float(perFragment);
+
+        sCrossSectionMaxData[0] = maxPoint.x();
+        sCrossSectionMaxData[1] = maxPoint.y();
+        sCrossSectionMaxData[2] = maxPoint.z();
+    }
+
+    static void bind()
+    {
+        // lazy initialization
+        // to avoid creating uniforms before bgfx is initialized
+        if (!sCrossSectionMinDataUniform.isValid())
+            sCrossSectionMinDataUniform =
+                Uniform("u_crossSectionMinData", bgfx::UniformType::Vec4);
+        if (!sCrossSectionMaxDataUniform.isValid())
+            sCrossSectionMaxDataUniform =
+                Uniform("u_crossSectionMaxData", bgfx::UniformType::Vec4);
+        sCrossSectionMinDataUniform.bind(sCrossSectionMinData.data());
+        sCrossSectionMaxDataUniform.bind(sCrossSectionMaxData.data());
+    }
+};
+
+} // namespace vcl
+
+#endif // VCL_BGFX_DRAWABLE_UNIFORMS_CROSS_SECTION_UNIFORMS_H

vclib/render/include/vclib/bgfx/primitives/lines.h

@@ -23,10 +23,13 @@
 #ifndef VCL_BGFX_PRIMITIVES_LINES_H
 #define VCL_BGFX_PRIMITIVES_LINES_H
 
+#include <vclib/bgfx/drawable/uniforms/cross_section_uniforms.h>
 #include <vclib/bgfx/primitives/lines/cpu_generated_lines.h>
 #include <vclib/bgfx/primitives/lines/primitive_lines.h>
 #include <vclib/bgfx/uniform.h>
 
+#include <vclib/render/settings/cross_section_settings.h>
+
 #include <vclib/base.h>
 #include <vclib/space/core.h>
 
@@ -90,6 +93,8 @@ class Lines
     ColorToUse mColorToUse      = ColorToUse::GENERAL;
     Color      mGeneralColor    = Color::ColorABGR::LightGray;
 
+    CrossSectionSettings mCrossSectionSettings;
+
     ImplementationType mType = ImplementationType::COUNT;
 
     std::variant<detail::PrimitiveLines, detail::CPUGeneratedLines>
@@ -385,6 +390,25 @@ class Lines
      */
     Color& generalColor() { return mGeneralColor; }
 
+    /**
+     * @brief Returns the current cross section settings.
+     * @return The current cross section settings.
+     */
+    const CrossSectionSettings& crossSectionSettings() const
+    {
+        return mCrossSectionSettings;
+    }
+
+    /**
+     * @brief Returns a reference to the current cross section settings. This
+     * allows to modify the settings directly.
+     * @return A reference to the current cross section settings.
+     */
+    CrossSectionSettings& crossSectionSettings()
+    {
+        return mCrossSectionSettings;
+    }
+
     /**
      * @brief Returns the current implementation type that is used to render
      * the lines.
@@ -533,6 +557,19 @@ class Lines
             std::bit_cast<float>(mGeneralColor.abgr()),
             mDepthOffset};
         sSettingUH.bind(data);
+
+        // cross section settings
+        if (mCrossSectionSettings.isEnabled()) {
+            using enum CrossSectionSettings::CrossSectionType;
+            CrossSectionUniforms::set(
+                mCrossSectionSettings.lower(),
+                mCrossSectionSettings.upper(),
+                mCrossSectionSettings.type() == PER_FRAGMENT);
+        }
+        else {
+            CrossSectionUniforms::set();
+        }
+        CrossSectionUniforms::bind();
     }
 };
 

vclib/render/include/vclib/qt/gui/mesh_render_settings_frame.h

@@ -23,9 +23,11 @@
 #ifndef VCL_QT_GUI_MESH_RENDER_SETTINGS_FRAME_H
 #define VCL_QT_GUI_MESH_RENDER_SETTINGS_FRAME_H
 
+#include "mesh_render_settings_frame/cross_section_settings_frame.h"
 #include "mesh_render_settings_frame/generic_mesh_render_settings_frame.h"
 
 #include <vclib/render/drawable/mesh/mesh_render_settings.h>
+#include <vclib/render/settings/cross_section_settings.h>
 
 #include <QFrame>
 
@@ -44,20 +46,27 @@ class MeshRenderSettingsFrame : public QFrame
     Ui::MeshRenderSettingsFrame* mUI;
     MeshRenderSettings           mMRS;
 
-    std::vector<GenericMeshRenderSettingsFrame*> frames;
+    std::vector<GenericMeshRenderSettingsFrame*> mFrames;
+    CrossSectionSettingsFrame*                   mCrossSectionFrame = nullptr;
 
 public:
     explicit MeshRenderSettingsFrame(QWidget* parent = nullptr);
     ~MeshRenderSettingsFrame();
 
     const MeshRenderSettings& meshRenderSettings() const;
 
+    const CrossSectionSettings& crossSectionSettings() const;
+
     void setMeshRenderSettings(
         const MeshRenderSettings& settings,
         bool                      changeCurrentTab = false);
 
+    void setCrossSectionSettings(const CrossSectionSettings& settings);
+
 signals:
-    void settingsUpdated();
+    void meshRenderSettingsUpdated();
+
+    void crossSectionSettingsUpdated();
 
 private:
     enum { POINTS_FRAME = 0, SURFACE_FRAME, WIREFRAME_FRAME, EDGES_FRAME };