- FVertexBuilder's output looks correct now.

src/CMakeLists.txt

@@ -1049,6 +1049,7 @@ set (PCH_SOURCES
 	gl/system/gl_buffers.cpp
 	gl/textures/gl_hwtexture.cpp
 	gl/textures/gl_samplers.cpp
+	hwrenderer/data/hw_vertexbuilder.cpp
 	hwrenderer/data/hw_sections.cpp
 	hwrenderer/data/flatvertices.cpp
 	hwrenderer/data/hw_viewpointbuffer.cpp

src/earcut.hpp

@@ -0,0 +1,790 @@
+/*
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE. 
+*/
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <vector>
+
+namespace mapbox {
+
+namespace util {
+
+template <std::size_t I, typename T> struct nth {
+    inline static typename std::tuple_element<I, T>::type
+    get(const T& t) { return std::get<I>(t); };
+};
+
+}
+
+namespace detail {
+
+template <typename N = uint32_t>
+class Earcut {
+public:
+    std::vector<N> indices;
+    std::size_t vertices = 0;
+
+    template <typename Polygon>
+    void operator()(const Polygon& points);
+
+private:
+    struct Node {
+        Node(N index, double x_, double y_) : i(index), x(x_), y(y_) {}
+        Node(const Node&) = delete;
+        Node& operator=(const Node&) = delete;
+        Node(Node&&) = delete;
+        Node& operator=(Node&&) = delete;
+
+        const N i;
+        const double x;
+        const double y;
+
+        // previous and next vertice nodes in a polygon ring
+        Node* prev = nullptr;
+        Node* next = nullptr;
+
+        // z-order curve value
+        int32_t z = 0;
+
+        // previous and next nodes in z-order
+        Node* prevZ = nullptr;
+        Node* nextZ = nullptr;
+
+        // indicates whether this is a steiner point
+        bool steiner = false;
+    };
+
+    template <typename Ring> Node* linkedList(const Ring& points, const bool clockwise);
+    Node* filterPoints(Node* start, Node* end = nullptr);
+    void earcutLinked(Node* ear, int pass = 0);
+    bool isEar(Node* ear);
+    bool isEarHashed(Node* ear);
+    Node* cureLocalIntersections(Node* start);
+    void splitEarcut(Node* start);
+    template <typename Polygon> Node* eliminateHoles(const Polygon& points, Node* outerNode);
+    void eliminateHole(Node* hole, Node* outerNode);
+    Node* findHoleBridge(Node* hole, Node* outerNode);
+    void indexCurve(Node* start);
+    Node* sortLinked(Node* list);
+    int32_t zOrder(const double x_, const double y_);
+    Node* getLeftmost(Node* start);
+    bool pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const;
+    bool isValidDiagonal(Node* a, Node* b);
+    double area(const Node* p, const Node* q, const Node* r) const;
+    bool equals(const Node* p1, const Node* p2);
+    bool intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2);
+    bool intersectsPolygon(const Node* a, const Node* b);
+    bool locallyInside(const Node* a, const Node* b);
+    bool middleInside(const Node* a, const Node* b);
+    Node* splitPolygon(Node* a, Node* b);
+    template <typename Point> Node* insertNode(std::size_t i, const Point& p, Node* last);
+    void removeNode(Node* p);
+
+    bool hashing;
+    double minX, maxX;
+    double minY, maxY;
+    double inv_size = 0;
+
+    template <typename T, typename Alloc = std::allocator<T>>
+    class ObjectPool {
+    public:
+        ObjectPool() { }
+        ObjectPool(std::size_t blockSize_) {
+            reset(blockSize_);
+        }
+        ~ObjectPool() {
+            clear();
+        }
+        template <typename... Args>
+        T* construct(Args&&... args) {
+            if (currentIndex >= blockSize) {
+                currentBlock = alloc.allocate(blockSize);
+                allocations.emplace_back(currentBlock);
+                currentIndex = 0;
+            }
+            T* object = &currentBlock[currentIndex++];
+            alloc.construct(object, std::forward<Args>(args)...);
+            return object;
+        }
+        void reset(std::size_t newBlockSize) {
+            for (auto allocation : allocations) alloc.deallocate(allocation, blockSize);
+            allocations.clear();
+            blockSize = std::max<std::size_t>(1, newBlockSize);
+            currentBlock = nullptr;
+            currentIndex = blockSize;
+        }
+        void clear() { reset(blockSize); }
+    private:
+        T* currentBlock = nullptr;
+        std::size_t currentIndex = 1;
+        std::size_t blockSize = 1;
+        std::vector<T*> allocations;
+        Alloc alloc;
+    };
+    ObjectPool<Node> nodes;
+};
+
+template <typename N> template <typename Polygon>
+void Earcut<N>::operator()(const Polygon& points) {
+    // reset
+    indices.clear();
+    vertices = 0;
+
+    if (points.empty()) return;
+
+    double x;
+    double y;
+    int threshold = 80;
+    std::size_t len = 0;
+
+    for (size_t i = 0; threshold >= 0 && i < points.size(); i++) {
+        threshold -= static_cast<int>(points[i].size());
+        len += points[i].size();
+    }
+
+    //estimate size of nodes and indices
+    nodes.reset(len * 3 / 2);
+    indices.reserve(len + points[0].size());
+
+    Node* outerNode = linkedList(points[0], true);
+    if (!outerNode) return;
+
+    if (points.size() > 1) outerNode = eliminateHoles(points, outerNode);
+
+    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+    hashing = threshold < 0;
+    if (hashing) {
+        Node* p = outerNode->next;
+        minX = maxX = outerNode->x;
+        minY = maxY = outerNode->y;
+        do {
+            x = p->x;
+            y = p->y;
+            minX = std::min<double>(minX, x);
+            minY = std::min<double>(minY, y);
+            maxX = std::max<double>(maxX, x);
+            maxY = std::max<double>(maxY, y);
+            p = p->next;
+        } while (p != outerNode);
+
+        // minX, minY and size are later used to transform coords into integers for z-order calculation
+        inv_size = std::max<double>(maxX - minX, maxY - minY);
+        inv_size = inv_size != .0 ? (1. / inv_size) : .0;
+    }
+
+    earcutLinked(outerNode);
+
+    nodes.clear();
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+template <typename N> template <typename Ring>
+typename Earcut<N>::Node*
+Earcut<N>::linkedList(const Ring& points, const bool clockwise) {
+    using Point = typename Ring::value_type;
+    double sum = 0;
+    const std::size_t len = points.size();
+    std::size_t i, j;
+    Node* last = nullptr;
+
+    // calculate original winding order of a polygon ring
+    for (i = 0, j = len > 0 ? len - 1 : 0; i < len; j = i++) {
+        const auto& p1 = points[i];
+        const auto& p2 = points[j];
+        const double p20 = util::nth<0, Point>::get(p2);
+        const double p10 = util::nth<0, Point>::get(p1);
+        const double p11 = util::nth<1, Point>::get(p1);
+        const double p21 = util::nth<1, Point>::get(p2);
+        sum += (p20 - p10) * (p11 + p21);
+    }
+
+    // link points into circular doubly-linked list in the specified winding order
+    if (clockwise == (sum > 0)) {
+        for (i = 0; i < len; i++) last = insertNode(vertices + i, points[i], last);
+    } else {
+        for (i = len; i-- > 0;) last = insertNode(vertices + i, points[i], last);
+    }
+
+    if (last && equals(last, last->next)) {
+        removeNode(last);
+        last = last->next;
+    }
+
+    vertices += len;
+
+    return last;
+}
+
+// eliminate colinear or duplicate points
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::filterPoints(Node* start, Node* end) {
+    if (!end) end = start;
+
+    Node* p = start;
+    bool again;
+    do {
+        again = false;
+
+        if (!p->steiner && (equals(p, p->next) /*|| area(p->prev, p, p->next) == 0*/)) 
+		{
+            removeNode(p);
+            p = end = p->prev;
+
+            if (p == p->next) break;
+            again = true;
+
+        } else {
+            p = p->next;
+        }
+    } while (again || p != end);
+
+    return end;
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+template <typename N>
+void Earcut<N>::earcutLinked(Node* ear, int pass) {
+    if (!ear) return;
+
+    // interlink polygon nodes in z-order
+    if (!pass && hashing) indexCurve(ear);
+
+    Node* stop = ear;
+    Node* prev;
+    Node* next;
+
+    int iterations = 0;
+
+    // iterate through ears, slicing them one by one
+    while (ear->prev != ear->next) {
+        iterations++;
+        prev = ear->prev;
+        next = ear->next;
+
+        if (hashing ? isEarHashed(ear) : isEar(ear)) {
+            // cut off the triangle
+            indices.emplace_back(prev->i);
+            indices.emplace_back(ear->i);
+            indices.emplace_back(next->i);
+
+            removeNode(ear);
+
+            // skipping the next vertice leads to less sliver triangles
+            ear = next->next;
+            stop = next->next;
+
+            continue;
+        }
+
+        ear = next;
+
+        // if we looped through the whole remaining polygon and can't find any more ears
+        if (ear == stop) {
+            // try filtering points and slicing again
+            if (!pass) earcutLinked(filterPoints(ear), 1);
+
+            // if this didn't work, try curing all small self-intersections locally
+            else if (pass == 1) {
+                ear = cureLocalIntersections(ear);
+                earcutLinked(ear, 2);
+
+            // as a last resort, try splitting the remaining polygon into two
+            } else if (pass == 2) splitEarcut(ear);
+
+            break;
+        }
+    }
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+template <typename N>
+bool Earcut<N>::isEar(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // now make sure we don't have other points inside the potential ear
+    Node* p = ear->next->next;
+
+    while (p != ear->prev) {
+        if (pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->next;
+    }
+
+    return true;
+}
+
+template <typename N>
+bool Earcut<N>::isEarHashed(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // triangle bbox; min & max are calculated like this for speed
+    const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
+    const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
+    const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
+    const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));
+
+    // z-order range for the current triangle bbox;
+    const int32_t minZ = zOrder(minTX, minTY);
+    const int32_t maxZ = zOrder(maxTX, maxTY);
+
+    // first look for points inside the triangle in increasing z-order
+    Node* p = ear->nextZ;
+
+    while (p && p->z <= maxZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->nextZ;
+    }
+
+    // then look for points in decreasing z-order
+    p = ear->prevZ;
+
+    while (p && p->z >= minZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->prevZ;
+    }
+
+    return true;
+}
+
+// go through all polygon nodes and cure small local self-intersections
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::cureLocalIntersections(Node* start) {
+    Node* p = start;
+    do {
+        Node* a = p->prev;
+        Node* b = p->next->next;
+
+        // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
+        if (!equals(a, b) && intersects(a, p, p->next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+            indices.emplace_back(a->i);
+            indices.emplace_back(p->i);
+            indices.emplace_back(b->i);
+
+            // remove two nodes involved
+            removeNode(p);
+            removeNode(p->next);
+
+            p = start = b;
+        }
+        p = p->next;
+    } while (p != start);
+
+    return p;
+}
+
+// try splitting polygon into two and triangulate them independently
+template <typename N>
+void Earcut<N>::splitEarcut(Node* start) {
+    // look for a valid diagonal that divides the polygon into two
+    Node* a = start;
+    do {
+        Node* b = a->next->next;
+        while (b != a->prev) {
+            if (a->i != b->i && isValidDiagonal(a, b)) {
+                // split the polygon in two by the diagonal
+                Node* c = splitPolygon(a, b);
+
+                // filter colinear points around the cuts
+                a = filterPoints(a, a->next);
+                c = filterPoints(c, c->next);
+
+                // run earcut on each half
+                earcutLinked(a);
+                earcutLinked(c);
+                return;
+            }
+            b = b->next;
+        }
+        a = a->next;
+    } while (a != start);
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+template <typename N> template <typename Polygon>
+typename Earcut<N>::Node*
+Earcut<N>::eliminateHoles(const Polygon& points, Node* outerNode) {
+    const size_t len = points.size();
+
+    std::vector<Node*> queue;
+    for (size_t i = 1; i < len; i++) {
+        Node* list = linkedList(points[i], false);
+        if (list) {
+            if (list == list->next) list->steiner = true;
+            queue.push_back(getLeftmost(list));
+        }
+    }
+    std::sort(queue.begin(), queue.end(), [](const Node* a, const Node* b) {
+        return a->x < b->x;
+    });
+
+    // process holes from left to right
+    for (size_t i = 0; i < queue.size(); i++) {
+        eliminateHole(queue[i], outerNode);
+        outerNode = filterPoints(outerNode, outerNode->next);
+    }
+
+    return outerNode;
+}
+
+// find a bridge between vertices that connects hole with an outer ring and and link it
+template <typename N>
+void Earcut<N>::eliminateHole(Node* hole, Node* outerNode) {
+    outerNode = findHoleBridge(hole, outerNode);
+    if (outerNode) {
+        Node* b = splitPolygon(outerNode, hole);
+        filterPoints(b, b->next);
+    }
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::findHoleBridge(Node* hole, Node* outerNode) {
+    Node* p = outerNode;
+    double hx = hole->x;
+    double hy = hole->y;
+    double qx = -std::numeric_limits<double>::infinity();
+    Node* m = nullptr;
+
+    // find a segment intersected by a ray from the hole's leftmost Vertex to the left;
+    // segment's endpoint with lesser x will be potential connection Vertex
+    do {
+        if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
+          double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
+          if (x <= hx && x > qx) {
+            qx = x;
+            if (x == hx) {
+                if (hy == p->y) return p;
+                if (hy == p->next->y) return p->next;
+            }
+            m = p->x < p->next->x ? p : p->next;
+          }
+        }
+        p = p->next;
+    } while (p != outerNode);
+
+    if (!m) return 0;
+
+    if (hx == qx) return m->prev;
+
+    // look for points inside the triangle of hole Vertex, segment intersection and endpoint;
+    // if there are no points found, we have a valid connection;
+    // otherwise choose the Vertex of the minimum angle with the ray as connection Vertex
+
+    const Node* stop = m;
+    double tanMin = std::numeric_limits<double>::infinity();
+    double tanCur = 0;
+
+    p = m->next;
+    double mx = m->x;
+    double my = m->y;
+
+    while (p != stop) {
+        if (hx >= p->x && p->x >= mx && hx != p->x &&
+            pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p->x, p->y)) {
+
+            tanCur = std::abs(hy - p->y) / (hx - p->x); // tangential
+
+            if ((tanCur < tanMin || (tanCur == tanMin && p->x > m->x)) && locallyInside(p, hole)) {
+                m = p;
+                tanMin = tanCur;
+            }
+        }
+
+        p = p->next;
+    }
+
+    return m;
+}
+
+// interlink polygon nodes in z-order
+template <typename N>
+void Earcut<N>::indexCurve(Node* start) {
+    assert(start);
+    Node* p = start;
+
+    do {
+        p->z = p->z ? p->z : zOrder(p->x, p->y);
+        p->prevZ = p->prev;
+        p->nextZ = p->next;
+        p = p->next;
+    } while (p != start);
+
+    p->prevZ->nextZ = nullptr;
+    p->prevZ = nullptr;
+
+    sortLinked(p);
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::sortLinked(Node* list) {
+    assert(list);
+    Node* p;
+    Node* q;
+    Node* e;
+    Node* tail;
+    int i, numMerges, pSize, qSize;
+    int inSize = 1;
+
+    for (;;) {
+        p = list;
+        list = nullptr;
+        tail = nullptr;
+        numMerges = 0;
+
+        while (p) {
+            numMerges++;
+            q = p;
+            pSize = 0;
+            for (i = 0; i < inSize; i++) {
+                pSize++;
+                q = q->nextZ;
+                if (!q) break;
+            }
+
+            qSize = inSize;
+
+            while (pSize > 0 || (qSize > 0 && q)) {
+
+                if (pSize == 0) {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                } else if (qSize == 0 || !q) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else if (p->z <= q->z) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                }
+
+                if (tail) tail->nextZ = e;
+                else list = e;
+
+                e->prevZ = tail;
+                tail = e;
+            }
+
+            p = q;
+        }
+
+        tail->nextZ = nullptr;
+
+        if (numMerges <= 1) return list;
+
+        inSize *= 2;
+    }
+}
+
+// z-order of a Vertex given coords and size of the data bounding box
+template <typename N>
+int32_t Earcut<N>::zOrder(const double x_, const double y_) {
+    // coords are transformed into non-negative 15-bit integer range
+    int32_t x = static_cast<int32_t>(32767.0 * (x_ - minX) * inv_size);
+    int32_t y = static_cast<int32_t>(32767.0 * (y_ - minY) * inv_size);
+
+    x = (x | (x << 8)) & 0x00FF00FF;
+    x = (x | (x << 4)) & 0x0F0F0F0F;
+    x = (x | (x << 2)) & 0x33333333;
+    x = (x | (x << 1)) & 0x55555555;
+
+    y = (y | (y << 8)) & 0x00FF00FF;
+    y = (y | (y << 4)) & 0x0F0F0F0F;
+    y = (y | (y << 2)) & 0x33333333;
+    y = (y | (y << 1)) & 0x55555555;
+
+    return x | (y << 1);
+}
+
+// find the leftmost node of a polygon ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::getLeftmost(Node* start) {
+    Node* p = start;
+    Node* leftmost = start;
+    do {
+        if (p->x < leftmost->x) leftmost = p;
+        p = p->next;
+    } while (p != start);
+
+    return leftmost;
+}
+
+// check if a point lies within a convex triangle
+template <typename N>
+bool Earcut<N>::pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const {
+    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
+           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
+           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+template <typename N>
+bool Earcut<N>::isValidDiagonal(Node* a, Node* b) {
+    return a->next->i != b->i && a->prev->i != b->i && !intersectsPolygon(a, b) &&
+           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
+}
+
+// signed area of a triangle
+template <typename N>
+double Earcut<N>::area(const Node* p, const Node* q, const Node* r) const {
+    return (q->y - p->y) * (r->x - q->x) - (q->x - p->x) * (r->y - q->y);
+}
+
+// check if two points are equal
+template <typename N>
+bool Earcut<N>::equals(const Node* p1, const Node* p2) {
+    return p1->x == p2->x && p1->y == p2->y;
+}
+
+// check if two segments intersect
+template <typename N>
+bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2) {
+    if ((equals(p1, q1) && equals(p2, q2)) ||
+        (equals(p1, q2) && equals(p2, q1))) return true;
+    return (area(p1, q1, p2) > 0) != (area(p1, q1, q2) > 0) &&
+           (area(p2, q2, p1) > 0) != (area(p2, q2, q1) > 0);
+}
+
+// check if a polygon diagonal intersects any polygon segments
+template <typename N>
+bool Earcut<N>::intersectsPolygon(const Node* a, const Node* b) {
+    const Node* p = a;
+    do {
+        if (p->i != a->i && p->next->i != a->i && p->i != b->i && p->next->i != b->i &&
+                intersects(p, p->next, a, b)) return true;
+        p = p->next;
+    } while (p != a);
+
+    return false;
+}
+
+// check if a polygon diagonal is locally inside the polygon
+template <typename N>
+bool Earcut<N>::locallyInside(const Node* a, const Node* b) {
+    return area(a->prev, a, a->next) < 0 ?
+        area(a, b, a->next) >= 0 && area(a, a->prev, b) >= 0 :
+        area(a, b, a->prev) < 0 || area(a, a->next, b) < 0;
+}
+
+// check if the middle Vertex of a polygon diagonal is inside the polygon
+template <typename N>
+bool Earcut<N>::middleInside(const Node* a, const Node* b) {
+    const Node* p = a;
+    bool inside = false;
+    double px = (a->x + b->x) / 2;
+    double py = (a->y + b->y) / 2;
+    do {
+        if (((p->y > py) != (p->next->y > py)) && p->next->y != p->y &&
+                (px < (p->next->x - p->x) * (py - p->y) / (p->next->y - p->y) + p->x))
+            inside = !inside;
+        p = p->next;
+    } while (p != a);
+
+    return inside;
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
+// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
+// single ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::splitPolygon(Node* a, Node* b) {
+    Node* a2 = nodes.construct(a->i, a->x, a->y);
+    Node* b2 = nodes.construct(b->i, b->x, b->y);
+    Node* an = a->next;
+    Node* bp = b->prev;
+
+    a->next = b;
+    b->prev = a;
+
+    a2->next = an;
+    an->prev = a2;
+
+    b2->next = a2;
+    a2->prev = b2;
+
+    bp->next = b2;
+    b2->prev = bp;
+
+    return b2;
+}
+
+// create a node and util::optionally link it with previous one (in a circular doubly linked list)
+template <typename N> template <typename Point>
+typename Earcut<N>::Node*
+Earcut<N>::insertNode(std::size_t i, const Point& pt, Node* last) {
+    Node* p = nodes.construct(static_cast<N>(i), util::nth<0, Point>::get(pt), util::nth<1, Point>::get(pt));
+
+    if (!last) {
+        p->prev = p;
+        p->next = p;
+
+    } else {
+        assert(last);
+        p->next = last->next;
+        p->prev = last;
+        last->next->prev = p;
+        last->next = p;
+    }
+    return p;
+}
+
+template <typename N>
+void Earcut<N>::removeNode(Node* p) {
+    p->next->prev = p->prev;
+    p->prev->next = p->next;
+
+    if (p->prevZ) p->prevZ->nextZ = p->nextZ;
+    if (p->nextZ) p->nextZ->prevZ = p->prevZ;
+}
+}
+
+template <typename N = uint32_t, typename Polygon>
+std::vector<N> earcut(const Polygon& poly) {
+    mapbox::detail::Earcut<N> earcut;
+    earcut(poly);
+    return std::move(earcut.indices);
+}
+}

src/hwrenderer/data/flatvertices.cpp

@@ -35,14 +35,6 @@
 #include "hwrenderer/data/buffers.h"
 #include "hwrenderer/scene/hw_renderstate.h"
 
-namespace VertexBuilder
-{
-    TArray<VertexContainer> BuildVertices();
-}
-
-using VertexContainers = TArray<VertexContainer>;
-
-
 //==========================================================================
 //
 //
@@ -179,7 +171,7 @@ int FFlatVertexBuffer::CreateIndexedSectorVertices(sector_t *sec, const secplane
 		vbo_shadowdata[vi + i].z += diff;
 	}
 
-    int rt = ibo_data.size();
+    int rt = ibo_data.Size();
     ibo_data.Append(verts.indices);
 	return rt;
 }
@@ -190,20 +182,20 @@ int FFlatVertexBuffer::CreateIndexedSectorVertices(sector_t *sec, const secplane
 //
 //==========================================================================
 
-int FFlatVertexBuffer::CreateIndexedVertices(int h, sector_t *sec, const secplane_t &plane, int floor, VertexContainers &verts)
+int FFlatVertexBuffer::CreateIndexedVertices(int h, sector_t *sec, const secplane_t &plane, int floor, VertexContainer &verts)
 {
 	sec->vboindex[h] = vbo_shadowdata.Size();
 	// First calculate the vertices for the sector itself
 	sec->vboheight[h] = sec->GetPlaneTexZ(h);
     sec->ibocount = verts.indices.Size();
-	sec->iboindex[h] = CreateIndexedSectorVertices(sec, plane, floor, verts[sec->Index()]);
+	sec->iboindex[h] = CreateIndexedSectorVertices(sec, plane, floor, verts);
 
 	// Next are all sectors using this one as heightsec
 	TArray<sector_t *> &fakes = sec->e->FakeFloor.Sectors;
 	for (unsigned g = 0; g < fakes.Size(); g++)
 	{
 		sector_t *fsec = fakes[g];
-		fsec->iboindex[2 + h] = CreateIndexedSectorVertices(fsec, plane, false, verts[fsec->Index()]);
+		fsec->iboindex[2 + h] = CreateIndexedSectorVertices(fsec, plane, false, verts);
 	}
 
 	// and finally all attached 3D floors
@@ -220,7 +212,7 @@ int FFlatVertexBuffer::CreateIndexedVertices(int h, sector_t *sec, const secplan
 
 			if (dotop || dobottom)
 			{
-				auto ndx = CreateIndexedSectorVertices(fsec, plane, false, verts[fsec->Index()]);
+				auto ndx = CreateIndexedSectorVertices(fsec, plane, false, verts);
 				if (dotop) ffloor->top.vindex = ndx;
 				if (dobottom) ffloor->bottom.vindex = ndx;
 			}
@@ -239,13 +231,32 @@ int FFlatVertexBuffer::CreateIndexedVertices(int h, sector_t *sec, const secplan
 
 void FFlatVertexBuffer::CreateIndexedFlatVertices()
 {
-    auto verts = VertexBuilder::BuildVertices();
+    auto verts = BuildVertices();
+
+	int i = 0;
+	for (auto &vert : verts)
+	{
+		Printf(PRINT_LOG, "Sector %d\n", i);
+		Printf(PRINT_LOG, "%d vertices, %d indices\n", vert.vertices.Size(), vert.indices.Size());
+		int j = 0;
+		for (auto &v : vert.vertices)
+		{
+			Printf(PRINT_LOG, "    %d: (%2.3f, %2.3f)\n", j++, v.vertex->fX(), v.vertex->fY());
+		}
+		for (unsigned i=0;i<vert.indices.Size();i+=3)
+		{
+			Printf(PRINT_LOG, "     %d, %d, %d\n", vert.indices[i], vert.indices[i + 1], vert.indices[i + 2]);
+		}
+
+		i++;
+	}
+
     
 	for (int h = sector_t::floor; h <= sector_t::ceiling; h++)
 	{
 		for (auto &sec : level.sectors)
 		{
-			CreateIndexedVertices(h, &sec, sec.GetSecPlane(h), h == sector_t::floor, verts);
+			CreateIndexedVertices(h, &sec, sec.GetSecPlane(h), h == sector_t::floor, verts[sec.Index()]);
 		}
 	}
 

src/hwrenderer/data/flatvertices.h

@@ -25,6 +25,7 @@
 
 #include "tarray.h"
 #include "hwrenderer/data/buffers.h"
+#include "hw_vertexbuilder.h"
 #include <atomic>
 #include <mutex>
 
@@ -117,7 +118,7 @@ public:
 private:
 	int CreateIndexedSectionVertices(subsector_t *sub, const secplane_t &plane, int floor, VertexContainer &cont);
 	int CreateIndexedSectorVertices(sector_t *sec, const secplane_t &plane, int floor, VertexContainer &cont);
-	int CreateIndexedVertices(int h, sector_t *sec, const secplane_t &plane, int floor, VertexContainers &cont);
+	int CreateIndexedVertices(int h, sector_t *sec, const secplane_t &plane, int floor, VertexContainer &cont);
 	void CreateIndexedFlatVertices();
 
 	void UpdatePlaneVertices(sector_t *sec, int plane);

src/hwrenderer/data/hw_sections.cpp

@@ -47,16 +47,6 @@ template<> struct THashTraits<DoublePoint>
 	int Compare(const DoublePoint &left, const DoublePoint &right) { return left != right; }
 };
 
-template<> struct THashTraits<FSectionVertex>
-{
-    hash_t Hash(const FSectionVertex &key)
-    {
-        return (int)(((intptr_t)key.vertex) >> 4) ^ (key.qualifier << 16);
-    }
-    int Compare(const FSectionVertex &left, const FSectionVertex &right) { return left.vertex != right.vertex && left.qualifier != right.qualifier; }
-};
-
-
 struct WorkSectionLine
 {
 	vertex_t *start;
@@ -77,6 +67,7 @@ struct WorkSection
 	bool hasminisegs;
 	TArray<WorkSectionLine*>segments;
 	TArray<side_t *> originalSides;	// The segs will lose some of these while working on them.
+	TArray<int> subsectors;
 };
 
 struct TriangleWorkData
@@ -107,7 +98,6 @@ class FSectionCreator
 
 	bool verbose = false;
 	TMap<int, TArray<int>> subsectormap;
-	TArray<TArray<int>> rawsections;	// list of unprocessed subsectors. Sector and mapsection can be retrieved from the elements so aren't stored.
 	TArray<WorkSection> sections;
 
 	TArray<TriangleWorkData> triangles;
@@ -185,16 +175,18 @@ public:
 	//
 	//==========================================================================
 
-	void CompileSections()
+	TArray < TArray<int>> CompileSections()
 	{
 		TMap<int, TArray<int>>::Pair *pair;
 		TMap<int, TArray<int>>::Iterator it(subsectormap);
+		TArray<TArray<int>> rawsections;	// list of unprocessed subsectors. Sector and mapsection can be retrieved from the elements so aren't stored.
 
 		while (it.NextPair(pair))
 		{
-			CompileSections(pair->Value);
+			CompileSections(pair->Value, rawsections);
 		}
 		subsectormap.Clear();
+		return rawsections;
 	}
 
 	//==========================================================================
@@ -203,7 +195,7 @@ public:
 	//
 	//==========================================================================
 
-	void CompileSections(TArray<int> &list)
+	void CompileSections(TArray<int> &list, TArray<TArray<int>>&rawsections)
 	{
 		TArray<int> sublist;
 		TArray<seg_t *> seglist;
@@ -255,12 +247,15 @@ public:
 
 	void MakeOutlines()
 	{
+		auto rawsections = CompileSections();
 		TArray<WorkSectionLine *> lineForSeg(level.segs.Size(), true);
 		memset(lineForSeg.Data(), 0, sizeof(WorkSectionLine*) * level.segs.Size());
 		for (auto &list : rawsections)
 		{
 			MakeOutline(list, lineForSeg);
 		}
+		rawsections.Clear();
+		rawsections.ShrinkToFit();
 
 		// Assign partners after everything has been collected
 		for (auto &section : sections)
@@ -403,8 +398,14 @@ public:
 					*sectionlines[i] = { nullptr, nullptr, nullptr, nullptr, -1, (int)sections.Size(), nullptr };
 				}
 			}
-
+			sections.Reserve(1);
-			sections.Push({ sector, mapsec, hasminisegs, std::move(sectionlines), std::move(foundsides) });
+			auto &section = sections.Last();
+			section.sectorindex = sector;
+			section.mapsection = mapsec;
+			section.hasminisegs = hasminisegs;
+			section.originalSides = std::move(foundsides);
+			section.segments = std::move(sectionlines);
+			section.subsectors = std::move(rawsection);
 		}
 	}
 
@@ -547,8 +548,8 @@ public:
 		{
 			groupForSection[workingSet[0].index] = groups.Size();
 			Group g;
+			g.subsectors = std::move(workingSet[0].section->subsectors);
 			g.groupedSections = std::move(workingSet);
-			g.subsectors = std::move(rawsections[workingSet[0].index]);
 			groups.Push(std::move(g));
 			return;
 		}
@@ -558,7 +559,7 @@ public:
 			build.Clear();
 			build.Push(workingSet[0]);
 			groupForSection[workingSet[0].index] = groups.Size();
-			subsectorcopy = std::move(rawsections[workingSet[0].index]);
+			subsectorcopy = std::move(workingSet[0].section->subsectors);
 			workingSet.Delete(0);
 
 
@@ -574,7 +575,7 @@ public:
 					{
 						build.Push(workingSet[i]);
 						groupForSection[workingSet[i].index] = groups.Size();
-						subsectorcopy.Append(rawsections[workingSet[i].index]);
+						subsectorcopy.Append(workingSet[i].section->subsectors);
 						workingSet.Delete(i);
 						i--;
 						continue;
@@ -585,7 +586,7 @@ public:
 					{
 						build.Push(workingSet[i]);
 						groupForSection[workingSet[i].index] = groups.Size();
-						subsectorcopy.Append(rawsections[workingSet[i].index]);
+						subsectorcopy.Append(workingSet[i].section->subsectors);
 						workingSet.Delete(i);
 						i--;
 						continue;
@@ -693,6 +694,8 @@ public:
 			if (output.firstSectionForSectorPtr[dest.sector->Index()] == -1)
 				output.firstSectionForSectorPtr[dest.sector->Index()] = curgroup;
 
+			output.numberOfSectionForSectorPtr[dest.sector->Index()]++;
+
 			for (auto &segment : group.segments)
 			{
 				// Use the indices calculated above to store these elements.
@@ -711,13 +714,11 @@ public:
 				output.allSides[numsides++] = &level.sides[pair->Key];
 				output.sectionForSidedefPtr[pair->Key] = curgroup;
 			}
-			memcpy(&output.allSubsectors[numsubsectors], &group.subsectors[0], group.subsectors.Size() * sizeof(subsector_t*));
 			for (auto ssi : group.subsectors)
 			{
+				output.allSubsectors[numsubsectors++] = &level.subsectors[ssi];
 				output.sectionForSubsectorPtr[ssi] = curgroup;
 			}
-			numsubsectors += group.subsectors.Size();
-			CreateVerticesForSection(output, dest, true);
 			curgroup++;
 		}
 	}
@@ -783,7 +784,6 @@ void CreateSections(FSectionContainer &container)
 {
 	FSectionCreator creat;
 	creat.GroupSubsectors();
-	creat.CompileSections();
 	creat.MakeOutlines();
 	creat.MergeLines();
 	creat.FindOuterLoops();
@@ -797,183 +797,3 @@ CCMD(printsections)
 }
 
 
-
-//=============================================================================
-//
-// One sector's vertex data.
-//
-//=============================================================================
-
-struct VertexContainer
-{
-	TArray<FSectionVertex> vertices;
-	TMap<FSectionVertex *, uint32_t> vertexmap;
-	bool perSubsector = false;
-	
-	TArray<uint32_t> indices;
-	
-	uint32_t AddVertex(FSectionVertex *vert)
-	{
-		auto check = vertexmap.CheckKey(vert);
-		if (check != nullptr) return *check;
-		auto index = vertices.Push(*vert);
-		vertexmap[vert] = index;
-		return index;
-	}
-	
-	uint32_t AddVertex(vertex_t *vert, int qualifier)
-	{
-		FSectionVertex vertx = { vert, qualifier};
-		return AddVertex(&vertx);
-	}
-	
-	uint32_t GetIndex(FSectionVertex *vert)
-	{
-		auto check = vertexmap.CheckKey(vert);
-		if (check != nullptr) return *check;
-		return ~0u;
-	}
-	
-	uint32_t GetIndex(vertex_t *vert, int qualifier)
-	{
-		FSectionVertex vertx = { vert, qualifier};
-		return GetIndex(&vertx);
-	}
-	
-	uint32_t AddIndexForVertex(FSectionVertex *vert)
-	{
-		return indices.Push(GetIndex(vert));
-	}
-	
-	uint32_t AddIndexForVertex(vertex_t *vert, int qualifier)
-	{
-		return indices.Push(GetIndex(vert, qualifier));
-	}
-	
-	uint32_t AddIndex(uint32_t indx)
-	{
-		return indices.Push(indx);
-	}
-};
-
-
-//=============================================================================
-//
-// Creates vertex meshes for sector planes
-//
-//=============================================================================
-
-namespace VertexBuilder
-{
-
-	//=============================================================================
-	//
-	//
-	//
-	//=============================================================================
-	
-	static void CreateVerticesForSubsector(subsector_t *sub, VertexContainer &gen, int qualifier)
-	{
-		if (sub->numlines < 3) return;
-		
-		uint32_t startindex = gen.indices.Size();
-		
-		if ((sub->flags & SSECF_HOLE) && sub->numlines > 3)
-		{
-			// Hole filling "subsectors" are not necessarily convex so they require real triangulation.
-			// These things are extremely rare so performance is secondary here.
-			
-			using Point = std::pair<double, double>;
-			std::vector<std::vector<Point>> polygon;
-			std::vector<Point> *curPoly;
-			
-			for (unsigned i = 0; i < sub->numlines; i++)
-			{
-				polygon.resize(1);
-				curPoly = &polygon.back();
-				curPoly->push_back({ sub->firstline[i].v1->fX(), sub->firstline[i].v1->fY() });
-			}
-			auto indices = mapbox::earcut(polygon);
-			for (auto vti : indices)
-			{
-				gen.AddIndexForVertex(sub->firstline[vti].v1, qualifier);
-			}
-		}
-		else
-		{
-			int firstndx = gen.GetIndex(sub->firstline[0].v1, qualifier);
-			int secondndx = gen.GetIndex(sub->firstline[1].v1, qualifier);
-			for (unsigned int k = 2; k < sub->numlines; k++)
-			{
-				gen.AddIndex(firstndx);
-				gen.AddIndex(secondndx);
-				auto ndx = gen.GetIndex(sub->firstline[k].v1, qualifier);
-				gen.AddIndex(ndx);
-				secondndx = ndx;
-			}
-		}
-	}
-	
-	//=============================================================================
-	//
-	//
-	//
-	//=============================================================================
-	
-	static void TriangulateSection(FSection &sect, VertexContainer &gen, int qualifier)
-	{
-		if (sect.segments.Size() < 3) return;
-		
-		// todo
-	}
-	
-	//=============================================================================
-	//
-	//
-	//
-	//=============================================================================
-	
-	
-	static void CreateVerticesForSection(FSection &section, VertexContainer &gen, bool useSubsectors)
-	{
-		section.vertexindex = gen.indices.Size();
-
-		if (useSubsectors)
-		{
-			for (auto sub : section.subsectors)
-			{
-				CreateVerticesForSubsector(sub, gen, -1);
-			}
-		}
-		else
-		{
-			TriangulateSection(section, gen, -1);
-		}
-		section.vertexcount = gen.indices.Size() - section.vertexindex;
-	}
-	
-	//==========================================================================
-	//
-	// Creates the vertices for one plane in one subsector
-	//
-	//==========================================================================
-	
-	static void CreateVerticesForSector(sector_t *sec, VertexContainer gen)
-	{
-		auto sections = level.sections.SectionsForSector(sec);
-		for (auto &section :sections)
-		{
-			CreateVerticesForSection( section, gen, true);
-		}
-	}
-	
-	TArray<VertexContainer> BuildVertices()
-	{
-		TArray<VertexContainer> verticesPerSector(level.sectors.Size(), true);
-		for (unsigned i=0; i<level.sectors.Size(); i++)
-		{
-			CreateVerticesForSector(&level.sectors[i], verticesPerSector[i]);
-		}
-	}
-
-};

src/hwrenderer/data/hw_sections.h

@@ -76,12 +76,6 @@ struct FSectionLine
 	side_t *sidedef;
 };
 
-struct FSectionVertex
-{
-	vertex_t *vertex;       // index into vertex array
-	int qualifier;          // some index to prevent vertices in different groups from being merged together.
-};
-
 struct FSection
 {
 	// tbd: Do we need a list of subsectors here? Ideally the subsectors should not be used anywhere anymore except for finding out where a location is.

src/hwrenderer/data/hw_vertexbuilder.cpp

@@ -0,0 +1,146 @@
+// 
+//---------------------------------------------------------------------------
+//
+// Copyright(C) 2015-2018 Christoph Oelckers
+// All rights reserved.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 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
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/
+//
+//--------------------------------------------------------------------------
+//
+
+
+
+#include "g_levellocals.h"
+#include "hw_vertexbuilder.h"
+#include "earcut.hpp"
+
+
+//=============================================================================
+//
+// Creates vertex meshes for sector planes
+//
+//=============================================================================
+
+//=============================================================================
+//
+//
+//
+//=============================================================================
+
+static void CreateVerticesForSubsector(subsector_t *sub, VertexContainer &gen, int qualifier)
+{
+	if (sub->numlines < 3) return;
+	
+	uint32_t startindex = gen.indices.Size();
+	
+	if ((sub->flags & SSECF_HOLE) && sub->numlines > 3)
+	{
+		// Hole filling "subsectors" are not necessarily convex so they require real triangulation.
+		// These things are extremely rare so performance is secondary here.
+		
+		using Point = std::pair<double, double>;
+		std::vector<std::vector<Point>> polygon;
+		std::vector<Point> *curPoly;
+		
+		for (unsigned i = 0; i < sub->numlines; i++)
+		{
+			polygon.resize(1);
+			curPoly = &polygon.back();
+			curPoly->push_back({ sub->firstline[i].v1->fX(), sub->firstline[i].v1->fY() });
+		}
+		auto indices = mapbox::earcut(polygon);
+		for (auto vti : indices)
+		{
+			gen.AddIndexForVertex(sub->firstline[vti].v1, qualifier);
+		}
+	}
+	else
+	{
+		int firstndx = gen.AddVertex(sub->firstline[0].v1, qualifier);
+		int secondndx = gen.AddVertex(sub->firstline[1].v1, qualifier);
+		for (unsigned int k = 2; k < sub->numlines; k++)
+		{
+			gen.AddIndex(firstndx);
+			gen.AddIndex(secondndx);
+			auto ndx = gen.AddVertex(sub->firstline[k].v1, qualifier);
+			gen.AddIndex(ndx);
+			secondndx = ndx;
+		}
+	}
+}
+
+//=============================================================================
+//
+//
+//
+//=============================================================================
+
+static void TriangulateSection(FSection &sect, VertexContainer &gen, int qualifier)
+{
+	if (sect.segments.Size() < 3) return;
+	
+	// todo
+}
+
+//=============================================================================
+//
+//
+//
+//=============================================================================
+
+
+static void CreateVerticesForSection(FSection &section, VertexContainer &gen, bool useSubsectors)
+{
+	section.vertexindex = gen.indices.Size();
+
+	if (useSubsectors)
+	{
+		for (auto sub : section.subsectors)
+		{
+			CreateVerticesForSubsector(sub, gen, -1);
+		}
+	}
+	else
+	{
+		TriangulateSection(section, gen, -1);
+	}
+	section.vertexcount = gen.indices.Size() - section.vertexindex;
+}
+
+//==========================================================================
+//
+// Creates the vertices for one plane in one subsector
+//
+//==========================================================================
+
+static void CreateVerticesForSector(sector_t *sec, VertexContainer &gen)
+{
+	auto sections = level.sections.SectionsForSector(sec);
+	for (auto &section :sections)
+	{
+		CreateVerticesForSection( section, gen, true);
+	}
+}
+
+
+TArray<VertexContainer> BuildVertices()
+{
+	TArray<VertexContainer> verticesPerSector(level.sectors.Size(), true);
+	for (unsigned i=0; i<level.sectors.Size(); i++)
+	{
+		CreateVerticesForSector(&level.sectors[i], verticesPerSector[i]);
+	}
+	return verticesPerSector;
+}

src/hwrenderer/data/hw_vertexbuilder.h

@@ -0,0 +1,69 @@
+
+#include "tarray.h"
+struct vertex_t;
+
+struct FQualifiedVertex
+{
+	vertex_t *vertex;       // index into vertex array
+	int qualifier;          // some index to prevent vertices in different groups from being merged together.
+};
+
+template<> struct THashTraits<FQualifiedVertex>
+{
+	hash_t Hash(const FQualifiedVertex &key)
+	{
+		return (int)(((intptr_t)key.vertex) >> 4) ^ (key.qualifier << 16);
+	}
+	int Compare(const FQualifiedVertex &left, const FQualifiedVertex &right) { return left.vertex != right.vertex || left.qualifier != right.qualifier; }
+};
+
+//=============================================================================
+//
+// One sector's vertex data.
+//
+//=============================================================================
+
+struct VertexContainer
+{
+	TArray<FQualifiedVertex> vertices;
+	TMap<FQualifiedVertex, uint32_t> vertexmap;
+	bool perSubsector = false;
+	
+	TArray<uint32_t> indices;
+	
+	uint32_t AddVertex(FQualifiedVertex *vert)
+	{
+		auto check = vertexmap.CheckKey(*vert);
+		if (check != nullptr) return *check;
+		auto index = vertices.Push(*vert);
+		vertexmap[*vert] = index;
+		return index;
+	}
+	
+	uint32_t AddVertex(vertex_t *vert, int qualifier)
+	{
+		FQualifiedVertex vertx = { vert, qualifier};
+		return AddVertex(&vertx);
+	}
+	
+	uint32_t AddIndexForVertex(FQualifiedVertex *vert)
+	{
+		return indices.Push(AddVertex(vert));
+	}
+	
+	uint32_t AddIndexForVertex(vertex_t *vert, int qualifier)
+	{
+		return indices.Push(AddVertex(vert, qualifier));
+	}
+	
+	uint32_t AddIndex(uint32_t indx)
+	{
+		return indices.Push(indx);
+	}
+};
+
+using VertexContainers = TArray<VertexContainer>;
+
+VertexContainers BuildVertices();
+
+

src/p_setup.cpp

@@ -4067,6 +4067,8 @@ void P_SetupLevel (const char *lumpname, int position, bool newGame)
 	for (i = 0; i < BODYQUESIZE; i++)
 		bodyque[i] = NULL;
 
+	CreateSections(level.sections);
+
 	if (!buildmap)
 	{
 		// [RH] Spawn slope creating things first.

src/r_data/renderinfo.cpp

@@ -532,8 +532,6 @@ static void PrepareSegs()
 
 void InitRenderInfo()
 {
-	CreateSections(level.sections);
-
 	PrepareSegs();
 	PrepareSectorData();
 	InitVertexData();

src/tarray.h

@@ -162,6 +162,10 @@ public:
 		Most = max;
 		Count = reserve? max : 0;
 		Array = (T *)M_Malloc (sizeof(T)*max);
+		if (reserve)
+		{
+			for (unsigned i = 0; i < Count; i++) ::new(&Array[i]) T();
+		}
 	}
 	TArray (const TArray<T,TT> &other)
 	{