meshstaticgeometrybuffers.h

Go to the documentation of this file.

 
#ifndef OPENSWMM_RENDER_MESHSTATICGEOMETRYBUFFERS_H
#define OPENSWMM_RENDER_MESHSTATICGEOMETRYBUFFERS_H
 
#include <QPointF>
#include <QVector>
#include <QtGlobal>
 
#include <algorithm>
#include <cstddef>
#include <utility>
#include <vector>
 
namespace OpenSWMM::Render
{
 
class MeshStaticGeometryBuffers
{
public:
    struct Vec2
    {
        float x = 0.0f;
        float y = 0.0f;
    };
 
    static constexpr quint64 kNoRevision = ~quint64(0);
 
    void clear()
    {
        m_positions.clear();
        m_triIndices.clear();
        m_triCell.clear();
        m_edgeEndpoints.clear();
        m_revision = kNoRevision;
        m_anchorX = m_anchorY = 0.0;
    }
 
    [[nodiscard]] bool isBuilt() const { return m_revision != kNoRevision; }
    [[nodiscard]] quint64 revision() const { return m_revision; }
    [[nodiscard]] double anchorX() const { return m_anchorX; }
    [[nodiscard]] double anchorY() const { return m_anchorY; }
 
    [[nodiscard]] const std::vector<Vec2>    &positions()  const { return m_positions; }
    [[nodiscard]] const std::vector<quint32> &triIndices() const { return m_triIndices; }
    [[nodiscard]] const std::vector<quint32> &triCell()    const { return m_triCell; }
    [[nodiscard]] const std::vector<quint32> &edgeEndpoints() const { return m_edgeEndpoints; }
 
    [[nodiscard]] qint64 vertexCount()   const { return qint64(m_positions.size()); }
    [[nodiscard]] qint64 triangleCount() const { return qint64(m_triIndices.size() / 3); }
    [[nodiscard]] qint64 edgeCount()     const { return qint64(m_edgeEndpoints.size() / 2); }
 
    template <typename TriAccessor>
    bool ensureBuilt(quint64 geomRevision,
                     double anchorX, double anchorY,
                     const QVector<QPointF> &vertices,
                     qint64 triCount,
                     TriAccessor &&triAccessor,
                     bool buildEdges = false)
    {
        // A triangle is a 3-vertex cell whose fan is itself.
        return ensureBuiltCells(
            geomRevision, anchorX, anchorY, vertices, triCount,
            [&](qint64 i, int poly[4], int &nv, int fan[2][3], int &nFan) {
                int v0 = -1, v1 = -1, v2 = -1;
                triAccessor(i, v0, v1, v2);
                poly[0] = v0; poly[1] = v1; poly[2] = v2; poly[3] = -1;
                nv = 3;
                fan[0][0] = v0; fan[0][1] = v1; fan[0][2] = v2;
                nFan = 1;
            },
            buildEdges);
    }
 
    template <typename CellAccessor>
    bool ensureBuiltCells(quint64 geomRevision,
                          double anchorX, double anchorY,
                          const QVector<QPointF> &vertices,
                          qint64 cellCount,
                          CellAccessor &&cellAccessor,
                          bool buildEdges = false)
    {
        if (m_revision == geomRevision
            && (!buildEdges || !m_edgeEndpoints.empty() || cellCount == 0))
            return false;
 
        m_anchorX = anchorX;
        m_anchorY = anchorY;
 
        m_positions.clear();
        m_positions.reserve(size_t(vertices.size()));
        for (const QPointF &p : vertices)
            m_positions.push_back(Vec2{float(p.x() - anchorX),
                                       float(p.y() - anchorY)});
 
        const int nVerts = int(vertices.size());
        m_triIndices.clear();
        m_triIndices.reserve(size_t(cellCount) * 3);
        m_triCell.clear();
        m_triCell.reserve(size_t(cellCount));
 
        // Undirected dedup via sorted (lo,hi) keys — from the polygon
        // boundary, not the fan.
        std::vector<quint64> keys;
        if (buildEdges) keys.reserve(size_t(cellCount) * 3);
        auto pushKey = [&keys](int u, int v) {
            if (u == v) return;
            const quint32 lo = quint32(std::min(u, v));
            const quint32 hi = quint32(std::max(u, v));
            keys.push_back((quint64(lo) << 32) | quint64(hi));
        };
 
        for (qint64 i = 0; i < cellCount; ++i) {
            int poly[4] = {-1, -1, -1, -1};
            int fan[2][3] = {{-1, -1, -1}, {-1, -1, -1}};
            int nv = 0, nFan = 0;
            cellAccessor(i, poly, nv, fan, nFan);
            if (nv < 3 || nv > 4 || nFan < 1 || nFan > 2) continue;
            bool valid = true;
            for (int k = 0; k < nv; ++k)
                if (poly[k] < 0 || poly[k] >= nVerts) { valid = false; break; }
            if (!valid) continue;   // drop invalid cells — indices stay valid
            for (int s = 0; s < nFan; ++s) {
                m_triIndices.push_back(quint32(fan[s][0]));
                m_triIndices.push_back(quint32(fan[s][1]));
                m_triIndices.push_back(quint32(fan[s][2]));
                m_triCell.push_back(quint32(i));
            }
            if (buildEdges)
                for (int k = 0; k < nv; ++k)
                    pushKey(poly[k], poly[(k + 1) % nv]);
        }
 
        m_edgeEndpoints.clear();
        if (buildEdges) {
            std::sort(keys.begin(), keys.end());
            keys.erase(std::unique(keys.begin(), keys.end()), keys.end());
            m_edgeEndpoints.reserve(keys.size() * 2);
            for (quint64 k : keys) {
                m_edgeEndpoints.push_back(quint32(k >> 32));
                m_edgeEndpoints.push_back(quint32(k & 0xffffffffu));
            }
        }
 
        m_revision = geomRevision;
        return true;
    }
 
private:
    std::vector<Vec2>    m_positions;
    std::vector<quint32> m_triIndices;
    std::vector<quint32> m_triCell;
    std::vector<quint32> m_edgeEndpoints;
    quint64 m_revision = kNoRevision;
    double  m_anchorX  = 0.0;
    double  m_anchorY  = 0.0;
};
 
} // namespace OpenSWMM::Render
 
#endif // OPENSWMM_RENDER_MESHSTATICGEOMETRYBUFFERS_H