diff --git a/src/ifcviewer-full/MainWindow.cpp b/src/ifcviewer-full/MainWindow.cpp index 2510ad799c..d7b7886b8c 100644 --- a/src/ifcviewer-full/MainWindow.cpp +++ b/src/ifcviewer-full/MainWindow.cpp @@ -210,11 +210,20 @@ void MainWindow::setupUi() { [this](int x, int y, int modifiers) { const bool alt = (modifiers & Qt::AltModifier) != 0; area_measurement_.onPick(*viewport_, x, y, alt); + viewport_->setHudText(QString("Area: %1 m² (%2 tris)") + .arg(area_measurement_.totalArea(), 0, 'f', 4) + .arg(area_measurement_.triangleCount())); }); connect(viewport_, &ViewportWindow::areaToolToggled, this, [this](bool active) { - area_measurement_.clear(); - qInfo("Area tool %s", active ? "on (LMB to add patch, Alt+LMB single tri, click again to remove, Esc exits)" : "off"); + area_measurement_.clear(*viewport_); + if (active) { + viewport_->setHudText("Area: 0.0000 m² (0 tris)"); + status_label_->setText("Area tool: LMB add, Alt+LMB single tri, click again to remove, Esc exits"); + } else { + viewport_->setHudText(QString()); + status_label_->setText("Ready"); + } }); auto* tree_dock = new QDockWidget("Elements", this); diff --git a/src/ifcviewer-full/Measurement.cpp b/src/ifcviewer-full/Measurement.cpp index 0fff48cda1..d487d7bd83 100644 --- a/src/ifcviewer-full/Measurement.cpp +++ b/src/ifcviewer-full/Measurement.cpp @@ -201,10 +201,40 @@ constexpr double kCoplanarDot = 0.9999; // ~0.81° tolerance AreaMeasurement::AreaMeasurement() = default; -void AreaMeasurement::clear() { +void AreaMeasurement::clear(ViewportWindow& vp) { mesh_cache_.clear(); selected_.clear(); total_area_m2_ = 0.0; + vp.setHighlightTriangles({}, 0, 0, 0, 0); +} + +void AreaMeasurement::rebuildHighlight(ViewportWindow& vp) { + // Push every selected triangle's three world-space vertices to the + // overlay. Mesh-local positions × per-instance composed transform. + std::vector world_xyz; + world_xyz.reserve(selected_.size() * 9); + for (const auto& [key, sel] : selected_) { + const uint64_t cache_key = (uint64_t(sel.model_id) << 32) + | uint64_t(sel.mesh_id); + auto cit = mesh_cache_.find(cache_key); + if (cit == mesh_cache_.end()) continue; + const MeshCache& c = cit->second; + if (size_t(sel.tri) * 3 + 2 >= c.indices.size()) continue; + const float* M = sel.composed_transform; // column-major + for (int e = 0; e < 3; ++e) { + const uint32_t vi = c.indices[3 * sel.tri + e]; + const float* p = &c.positions[3 * vi]; + // World = M * (p, 1). Column-major: M[col*4 + row]. + const float wx = M[0]*p[0] + M[4]*p[1] + M[8]*p[2] + M[12]; + const float wy = M[1]*p[0] + M[5]*p[1] + M[9]*p[2] + M[13]; + const float wz = M[2]*p[0] + M[6]*p[1] + M[10]*p[2] + M[14]; + world_xyz.push_back(wx); + world_xyz.push_back(wy); + world_xyz.push_back(wz); + } + } + // Translucent cyan-ish tint — readable on both light and dark surfaces. + vp.setHighlightTriangles(world_xyz, 0.20f, 0.85f, 1.00f, 0.45f); } AreaMeasurement::MeshCache* AreaMeasurement::meshCache(ViewportWindow& vp, @@ -304,19 +334,33 @@ void AreaMeasurement::onPick(ViewportWindow& vp, int x, int y, bool alt) { // Toggle: if the seed was already in the set, remove the patch; // otherwise add it. - const uint64_t seed_key = triKey(pick.model_id, pick.mesh_id, seed); + const uint64_t seed_key = triKey(pick.object_id, seed); const bool removing = selected_.count(seed_key) > 0; double delta = 0.0; for (uint32_t t : patch) { - const uint64_t k = triKey(pick.model_id, pick.mesh_id, t); + const uint64_t k = triKey(pick.object_id, t); if (removing) { - if (selected_.erase(k) > 0) delta -= cache->tri_areas[t]; + auto it = selected_.find(k); + if (it != selected_.end()) { + delta -= cache->tri_areas[t]; + selected_.erase(it); + } } else { - if (selected_.insert(k).second) delta += cache->tri_areas[t]; + SelectedTri sel; + sel.model_id = pick.model_id; + sel.mesh_id = pick.mesh_id; + sel.tri = t; + std::memcpy(sel.composed_transform, pick.composed_transform, + sizeof(sel.composed_transform)); + if (selected_.emplace(k, sel).second) { + delta += cache->tri_areas[t]; + } } } total_area_m2_ += delta; + rebuildHighlight(vp); + qInfo("Area %s%.6f m^2 (total: %.6f m^2, %zu tris)", delta >= 0.0 ? "+" : "", delta, total_area_m2_, selected_.size()); diff --git a/src/ifcviewer-full/Measurement.h b/src/ifcviewer-full/Measurement.h index e88f650bd6..4b0c3d4bd0 100644 --- a/src/ifcviewer-full/Measurement.h +++ b/src/ifcviewer-full/Measurement.h @@ -22,7 +22,6 @@ #include #include -#include #include class ViewportWindow; @@ -38,14 +37,16 @@ double volumeOfObjects(ViewportWindow& vp, const std::vector& object_ids); // Click-to-accumulate area measurement. Each pick resolves the screen -// click to a (model, mesh, triangle) using ViewportWindow's primitives, +// click to a (instance, triangle) using ViewportWindow's primitives, // expands it into the connected coplanar patch (BFS over shared edges, // dot(normal, seed_normal) > 0.9999), then either adds or removes that // patch from the running set depending on whether the seed triangle was // already in. Alt-click skips the BFS expansion (single-triangle). -// Picks across different meshes are kept as separate patches and their -// areas are summed. +// Picks on different instances (even of the same mesh) are kept as +// separate patches and their areas are summed. // +// On every pick the world-space triangles of the running set are pushed +// to ViewportWindow::setHighlightTriangles for in-viewport shading. // State is cleared on construction, on clear(), and is expected to be // reset by the host (e.g. when the viewport's area tool toggles off). class AreaMeasurement { @@ -57,8 +58,9 @@ public: // via qInfo. Misses are silent. void onPick(ViewportWindow& vp, int x, int y, bool alt); - // Wipe all accumulated triangles and per-mesh adjacency caches. - void clear(); + // Wipe all accumulated triangles, per-mesh adjacency caches, and the + // viewport overlay. + void clear(ViewportWindow& vp); double totalArea() const { return total_area_m2_; } size_t triangleCount() const { return selected_.size(); } @@ -77,16 +79,29 @@ private: }; MeshCache* meshCache(ViewportWindow& vp, uint32_t model_id, uint32_t mesh_id); - // Selection key: (uint64) packing model_id (high 24), mesh_id (mid 24), - // triangle index (low 16). 16 bits is enough — meshes with > 65k tris - // are rare and the streamer chunks them anyway. - static uint64_t triKey(uint32_t model_id, uint32_t mesh_id, uint32_t tri) { - return (uint64_t(model_id) << 40) | (uint64_t(mesh_id) << 16) | uint64_t(tri); + // Per-selected-triangle record. The composed transform is captured at + // pick time so the overlay rebuild doesn't have to re-query the + // viewport for it (and so the overlay keeps working if the picked + // instance later goes hidden). + struct SelectedTri { + uint32_t model_id; + uint32_t mesh_id; + uint32_t tri; + float composed_transform[16]; + }; + + // Selection key: object_id (high 32) | tri index (low 32). Packing + // by object_id rather than mesh_id means two distinct instances of + // the same mesh contribute independently, as the user spec'd. + static uint64_t triKey(uint32_t object_id, uint32_t tri) { + return (uint64_t(object_id) << 32) | uint64_t(tri); } - std::unordered_map mesh_cache_; - std::unordered_set selected_; - double total_area_m2_ = 0.0; + void rebuildHighlight(ViewportWindow& vp); + + std::unordered_map mesh_cache_; + std::unordered_map selected_; + double total_area_m2_ = 0.0; }; #endif // IFCVIEWER_FULL_MEASUREMENT_H diff --git a/src/ifcviewer/OverlayRenderer.cpp b/src/ifcviewer/OverlayRenderer.cpp new file mode 100644 index 0000000000..60384061ac --- /dev/null +++ b/src/ifcviewer/OverlayRenderer.cpp @@ -0,0 +1,199 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell 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 * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +#include "OverlayRenderer.h" + +#include +#include +#include +#include +#include + +namespace { + +GLuint compile(QOpenGLFunctions_4_5_Core* gl, GLenum type, const char* src) { + GLuint s = gl->glCreateShader(type); + gl->glShaderSource(s, 1, &src, nullptr); + gl->glCompileShader(s); + GLint ok = 0; + gl->glGetShaderiv(s, GL_COMPILE_STATUS, &ok); + if (!ok) { + char log[2048]; + gl->glGetShaderInfoLog(s, sizeof(log), nullptr, log); + qWarning("OverlayRenderer shader compile error: %s", log); + } + return s; +} + +GLuint link(QOpenGLFunctions_4_5_Core* gl, GLuint vs, GLuint fs) { + GLuint p = gl->glCreateProgram(); + gl->glAttachShader(p, vs); + gl->glAttachShader(p, fs); + gl->glLinkProgram(p); + GLint ok = 0; + gl->glGetProgramiv(p, GL_LINK_STATUS, &ok); + if (!ok) { + char log[2048]; + gl->glGetProgramInfoLog(p, sizeof(log), nullptr, log); + qWarning("OverlayRenderer program link error: %s", log); + } + gl->glDeleteShader(vs); + gl->glDeleteShader(fs); + return p; +} + +const char* VERT_SRC = R"( +#version 450 core +layout(location = 0) in vec3 in_pos; +uniform mat4 u_view_proj; +void main() { + gl_Position = u_view_proj * vec4(in_pos, 1.0); +} +)"; + +const char* FRAG_SRC = R"( +#version 450 core +uniform vec4 u_color; +out vec4 frag_color; +void main() { + frag_color = u_color; +} +)"; + +} // namespace + +void OverlayRenderer::initialize(QOpenGLFunctions_4_5_Core* gl) { + if (gl_) return; + gl_ = gl; + + GLuint vs = compile(gl_, GL_VERTEX_SHADER, VERT_SRC); + GLuint fs = compile(gl_, GL_FRAGMENT_SHADER, FRAG_SRC); + program_ = link(gl_, vs, fs); + u_view_proj_ = gl_->glGetUniformLocation(program_, "u_view_proj"); + u_color_ = gl_->glGetUniformLocation(program_, "u_color"); + + gl_->glCreateVertexArrays(1, &vao_); + gl_->glCreateBuffers(1, &vbo_); + gl_->glEnableVertexArrayAttrib(vao_, 0); + gl_->glVertexArrayAttribFormat(vao_, 0, 3, GL_FLOAT, GL_FALSE, 0); + gl_->glVertexArrayAttribBinding(vao_, 0, 0); + gl_->glVertexArrayVertexBuffer(vao_, 0, vbo_, 0, 3 * sizeof(float)); +} + +void OverlayRenderer::release() { + if (!gl_) return; + if (vbo_) gl_->glDeleteBuffers(1, &vbo_); + if (vao_) gl_->glDeleteVertexArrays(1, &vao_); + if (program_) gl_->glDeleteProgram(program_); + program_ = vao_ = vbo_ = 0; + vbo_capacity_ = 0; + vertex_count_ = 0; + gl_ = nullptr; +} + +void OverlayRenderer::setHudText(const QString& text) { + hud_text_ = text; +} + +void OverlayRenderer::setHighlightTriangles(const std::vector& world_xyz, + float r, float g, float b, float a) { + if (!gl_) return; + color_[0] = r; color_[1] = g; color_[2] = b; color_[3] = a; + vertex_count_ = GLsizei(world_xyz.size() / 3); + if (vertex_count_ == 0) return; + + const size_t bytes = world_xyz.size() * sizeof(float); + if (bytes > vbo_capacity_) { + // Grow with a little headroom so frequent appends don't realloc. + const size_t new_cap = bytes + bytes / 2; + gl_->glNamedBufferData(vbo_, GLsizeiptr(new_cap), + nullptr, GL_DYNAMIC_DRAW); + vbo_capacity_ = new_cap; + } + gl_->glNamedBufferSubData(vbo_, 0, GLsizeiptr(bytes), world_xyz.data()); +} + +void OverlayRenderer::render(const float view_proj[16], + int pixel_w, int pixel_h, qreal dpr) { + if (!gl_) return; + + // GL pass: tinted highlight triangles. + if (program_ && vertex_count_ > 0 && color_[3] > 0.0f) { + gl_->glUseProgram(program_); + gl_->glUniformMatrix4fv(u_view_proj_, 1, GL_FALSE, view_proj); + gl_->glUniform4fv(u_color_, 1, color_); + + // Save the GL state we touch and restore at the end so the rest of + // the render pass keeps seeing what it expects. + GLboolean prev_blend = gl_->glIsEnabled(GL_BLEND); + GLboolean prev_cull = gl_->glIsEnabled(GL_CULL_FACE); + GLboolean prev_depth_msk = GL_TRUE; + gl_->glGetBooleanv(GL_DEPTH_WRITEMASK, &prev_depth_msk); + GLint prev_depth_func = GL_LESS; + gl_->glGetIntegerv(GL_DEPTH_FUNC, &prev_depth_func); + GLint prev_blend_src = GL_ONE, prev_blend_dst = GL_ZERO; + gl_->glGetIntegerv(GL_BLEND_SRC_ALPHA, &prev_blend_src); + gl_->glGetIntegerv(GL_BLEND_DST_ALPHA, &prev_blend_dst); + + gl_->glEnable(GL_BLEND); + gl_->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl_->glDisable(GL_CULL_FACE); // both sides tinted + gl_->glDepthMask(GL_FALSE); // tint, don't occlude + gl_->glDepthFunc(GL_LEQUAL); // win the coplanar fight + + gl_->glBindVertexArray(vao_); + gl_->glDrawArrays(GL_TRIANGLES, 0, vertex_count_); + gl_->glBindVertexArray(0); + + if (!prev_blend) gl_->glDisable(GL_BLEND); + gl_->glBlendFunc(prev_blend_src, prev_blend_dst); + if (prev_cull) gl_->glEnable(GL_CULL_FACE); + gl_->glDepthMask(prev_depth_msk); + gl_->glDepthFunc(prev_depth_func); + } + + // QPainter pass: HUD text. This rebinds programs/VAOs internally, so + // it has to come after every other GL primitive in the overlay. + if (!hud_text_.isEmpty() && pixel_w > 0 && pixel_h > 0) { + QOpenGLPaintDevice device(QSize(pixel_w, pixel_h)); + device.setDevicePixelRatio(dpr); + QPainter painter(&device); + painter.setRenderHint(QPainter::Antialiasing); + painter.setRenderHint(QPainter::TextAntialiasing); + + QFont font("monospace", 11); + font.setStyleHint(QFont::TypeWriter); + painter.setFont(font); + const QFontMetrics fm(font); + const int pad_x = 10, pad_y = 6, margin = 12; + const int text_w = fm.horizontalAdvance(hud_text_); + const int text_h = fm.height(); + const QRect bg(margin, margin, + text_w + 2 * pad_x, + text_h + 2 * pad_y); + + painter.setPen(Qt::NoPen); + painter.setBrush(QColor(0, 0, 0, 160)); + painter.drawRoundedRect(bg, 4, 4); + painter.setPen(Qt::white); + painter.drawText(bg.adjusted(pad_x, pad_y, -pad_x, -pad_y), + Qt::AlignLeft | Qt::AlignVCenter, + hud_text_); + } +} diff --git a/src/ifcviewer/OverlayRenderer.h b/src/ifcviewer/OverlayRenderer.h new file mode 100644 index 0000000000..78f343c9b2 --- /dev/null +++ b/src/ifcviewer/OverlayRenderer.h @@ -0,0 +1,75 @@ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell 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 * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + +#ifndef IFCVIEWER_OVERLAYRENDERER_H +#define IFCVIEWER_OVERLAYRENDERER_H + +#include +#include + +#include + +// Neutral overlay-primitive renderer attached to ViewportWindow. Today it +// draws a single tinted, translucent triangle list in world space — used by +// the area-measurement tool to shade selected coplanar patches. More +// primitives (lines, points, world-anchored labels) will land here as +// future tools require them. +// +// Lifetime: owned by ViewportWindow, initialised in the same context. All +// public methods assume the caller has already made the GL context current. +class OverlayRenderer { +public: + void initialize(QOpenGLFunctions_4_5_Core* gl); + void release(); + + // Replace the highlight-triangle list. `world_xyz` is 3 floats per + // vertex, 3 verts per triangle, in world space (post-composed-transform). + // Empty disables the overlay. Color is RGBA in [0, 1]. + void setHighlightTriangles(const std::vector& world_xyz, + float r, float g, float b, float a); + + // Top-left HUD text drawn via QPainter on the GL surface as part of + // render(). Empty hides the HUD. + void setHudText(const QString& text); + + // Render every overlay primitive in order: GL highlight triangles + // (using `view_proj`, column-major float[16]), then HUD text via + // QPainter on a QOpenGLPaintDevice sized to (pixel_w × pixel_h) + // with the supplied device pixel ratio. Caller is responsible for + // ensuring glViewport covers the full surface — the QPainter pass + // after this call leaves GL state in an undefined shape, so treat + // this as the last GL operation per frame before swapBuffers (or + // sandwich it before any pass that re-binds its own programs). + void render(const float view_proj[16], + int pixel_w, int pixel_h, qreal device_pixel_ratio); + +private: + QOpenGLFunctions_4_5_Core* gl_ = nullptr; + GLuint program_ = 0; + GLuint vao_ = 0; + GLuint vbo_ = 0; + size_t vbo_capacity_ = 0; // bytes + GLsizei vertex_count_ = 0; + float color_[4] = {0, 0, 0, 0}; + GLint u_view_proj_ = -1; + GLint u_color_ = -1; + QString hud_text_; +}; + +#endif // IFCVIEWER_OVERLAYRENDERER_H diff --git a/src/ifcviewer/ViewportWindow.cpp b/src/ifcviewer/ViewportWindow.cpp index 907f4c6a02..081f5e5585 100644 --- a/src/ifcviewer/ViewportWindow.cpp +++ b/src/ifcviewer/ViewportWindow.cpp @@ -670,6 +670,7 @@ ViewportWindow::~ViewportWindow() { if (hiz_resolve_depth_tex_) gl_->glDeleteTextures(1, &hiz_resolve_depth_tex_); if (hiz_downsample_program_) gl_->glDeleteProgram(hiz_downsample_program_); if (hiz_downsample_vao_) gl_->glDeleteVertexArrays(1, &hiz_downsample_vao_); + overlay_renderer_.release(); } context_->doneCurrent(); } @@ -690,6 +691,7 @@ void ViewportWindow::initGL() { buildAxisGizmo(); buildPivotIndicator(); buildSectionPlaneGizmo(); + overlay_renderer_.initialize(gl_); gl_->glEnable(GL_DEPTH_TEST); gl_->glEnable(GL_MULTISAMPLE); @@ -2726,6 +2728,16 @@ void ViewportWindow::render() { renderEdgePass(); renderPivotIndicator(); renderSectionPlanes(); + // Overlay handles highlight tris + HUD text; renderAxisGizmo() must + // come after because it shrinks glViewport to the corner badge and + // does not restore. + { + const qreal dpr = devicePixelRatio(); + overlay_renderer_.render(vp.constData(), + int(width() * dpr), + int(height() * dpr), + dpr); + } renderAxisGizmo(); // Build HiZ from this frame's resolved depth for next frame's cull. @@ -3848,6 +3860,8 @@ bool ViewportWindow::pickMeshLocalAt(int x, int y, MeshLocalPick& out) { out.world_normal[0] = world_normal.x(); out.world_normal[1] = world_normal.y(); out.world_normal[2] = world_normal.z(); + std::memcpy(out.composed_transform, inst.transform, + sizeof(out.composed_transform)); return true; } } @@ -3858,3 +3872,16 @@ void ViewportWindow::toggleAreaTool() { area_tool_active_ = !area_tool_active_; emit areaToolToggled(area_tool_active_); } + +void ViewportWindow::setHighlightTriangles(const std::vector& world_xyz, + float r, float g, float b, float a) { + if (!gl_initialized_) return; + context_->makeCurrent(this); + overlay_renderer_.setHighlightTriangles(world_xyz, r, g, b, a); + requestUpdate(); +} + +void ViewportWindow::setHudText(const QString& text) { + overlay_renderer_.setHudText(text); + requestUpdate(); +} diff --git a/src/ifcviewer/ViewportWindow.h b/src/ifcviewer/ViewportWindow.h index c436dda57c..132c6acb65 100644 --- a/src/ifcviewer/ViewportWindow.h +++ b/src/ifcviewer/ViewportWindow.h @@ -45,6 +45,7 @@ QT_END_NAMESPACE #include "BvhAccel.h" #include "InstancedGeometry.h" +#include "OverlayRenderer.h" #include "SidecarCache.h" // Matches GL_DRAW_INDIRECT_BUFFER layout for glMultiDrawElementsIndirect. @@ -221,6 +222,11 @@ public: float mesh_local[3] = {0, 0, 0}; float world_pos[3] = {0, 0, 0}; float world_normal[3]= {0, 0, 0}; + // The instance's composed (FederatedFalseOrigin · ModelTransformation + // · CoordinateOperation · placement_transformation) matrix in + // column-major form. Mesh-local positions × this = world. Caching + // by callers becomes stale if any federation matrix is later edited. + float composed_transform[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1}; }; bool pickMeshLocalAt(int x, int y, MeshLocalPick& out); @@ -231,6 +237,19 @@ public: void toggleAreaTool(); bool areaToolActive() const { return area_tool_active_; } + // Replace the overlay highlight-triangle list rendered after the main + // pass. `world_xyz` is 3 floats per vertex, 3 verts per triangle, in + // world space. Empty disables the overlay. Triggers a viewport + // update so the change becomes visible immediately. + void setHighlightTriangles(const std::vector& world_xyz, + float r, float g, float b, float a); + + // Top-left HUD text drawn via QPainter on top of the GL surface at + // the end of each frame. Empty hides the HUD. Used today by the + // area-measurement tool for the running total; later tools can pile + // additional readouts in by extending this with a multi-line API. + void setHudText(const QString& text); + // Federation pipeline: composed instance transform = // FederatedFalseOrigin · ModelTransformation · CoordinateOperation // · placement_transformation @@ -635,6 +654,11 @@ private: // Area-measurement tool: see toggleAreaTool / surfacePickedInTool. bool area_tool_active_ = false; + // Renders any client-supplied overlay primitives (highlight triangles + // today; lines/points/labels later) in their own pass after the main + // geometry, with depth-test on / depth-write off. + OverlayRenderer overlay_renderer_; + // Active section planes. Uploaded as uniform array each frame to the // main + pick programs; capped at MaxSectionPlanes. std::vector section_planes_;