diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 559379a6d9..da9b92dda1 100644 --- a/src/CMakeLists.txt +++ b/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 diff --git a/src/earcut.hpp b/src/earcut.hpp new file mode 100644 index 0000000000..d6a2c97988 --- /dev/null +++ b/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 +#include +#include +#include +#include + +namespace mapbox { + +namespace util { + +template struct nth { + inline static typename std::tuple_element::type + get(const T& t) { return std::get(t); }; +}; + +} + +namespace detail { + +template +class Earcut { +public: + std::vector indices; + std::size_t vertices = 0; + + template + 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 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 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 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 > + class ObjectPool { + public: + ObjectPool() { } + ObjectPool(std::size_t blockSize_) { + reset(blockSize_); + } + ~ObjectPool() { + clear(); + } + template + T* construct(Args&&... args) { + if (currentIndex >= blockSize) { + currentBlock = alloc.allocate(blockSize); + allocations.emplace_back(currentBlock); + currentIndex = 0; + } + T* object = ¤tBlock[currentIndex++]; + alloc.construct(object, std::forward(args)...); + return object; + } + void reset(std::size_t newBlockSize) { + for (auto allocation : allocations) alloc.deallocate(allocation, blockSize); + allocations.clear(); + blockSize = std::max(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 allocations; + Alloc alloc; + }; + ObjectPool nodes; +}; + +template template +void Earcut::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(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(minX, x); + minY = std::min(minY, y); + maxX = std::max(maxX, x); + maxY = std::max(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(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 template +typename Earcut::Node* +Earcut::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 Earcut::Node* +Earcut::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 +void Earcut::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 +bool Earcut::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 +bool Earcut::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(a->x, std::min(b->x, c->x)); + const double minTY = std::min(a->y, std::min(b->y, c->y)); + const double maxTX = std::max(a->x, std::max(b->x, c->x)); + const double maxTY = std::max(a->y, std::max(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 Earcut::Node* +Earcut::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 +void Earcut::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 template +typename Earcut::Node* +Earcut::eliminateHoles(const Polygon& points, Node* outerNode) { + const size_t len = points.size(); + + std::vector 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 +void Earcut::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 Earcut::Node* +Earcut::findHoleBridge(Node* hole, Node* outerNode) { + Node* p = outerNode; + double hx = hole->x; + double hy = hole->y; + double qx = -std::numeric_limits::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::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 +void Earcut::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 Earcut::Node* +Earcut::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 +int32_t Earcut::zOrder(const double x_, const double y_) { + // coords are transformed into non-negative 15-bit integer range + int32_t x = static_cast(32767.0 * (x_ - minX) * inv_size); + int32_t y = static_cast(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 Earcut::Node* +Earcut::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 +bool Earcut::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 +bool Earcut::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 +double Earcut::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 +bool Earcut::equals(const Node* p1, const Node* p2) { + return p1->x == p2->x && p1->y == p2->y; +} + +// check if two segments intersect +template +bool Earcut::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 +bool Earcut::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 +bool Earcut::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 +bool Earcut::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 Earcut::Node* +Earcut::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 template +typename Earcut::Node* +Earcut::insertNode(std::size_t i, const Point& pt, Node* last) { + Node* p = nodes.construct(static_cast(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 +void Earcut::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 +std::vector earcut(const Polygon& poly) { + mapbox::detail::Earcut earcut; + earcut(poly); + return std::move(earcut.indices); +} +} diff --git a/src/hwrenderer/data/flatvertices.cpp b/src/hwrenderer/data/flatvertices.cpp index c19169db36..3083cbc098 100644 --- a/src/hwrenderer/data/flatvertices.cpp +++ b/src/hwrenderer/data/flatvertices.cpp @@ -35,14 +35,6 @@ #include "hwrenderer/data/buffers.h" #include "hwrenderer/scene/hw_renderstate.h" -namespace VertexBuilder -{ - TArray BuildVertices(); -} - -using VertexContainers = TArray; - - //========================================================================== // // @@ -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 &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 #include @@ -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); diff --git a/src/hwrenderer/data/hw_sections.cpp b/src/hwrenderer/data/hw_sections.cpp index 31c1986e6a..4ad20d47a3 100644 --- a/src/hwrenderer/data/hw_sections.cpp +++ b/src/hwrenderer/data/hw_sections.cpp @@ -47,16 +47,6 @@ template<> struct THashTraits int Compare(const DoublePoint &left, const DoublePoint &right) { return left != right; } }; -template<> struct THashTraits -{ - 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; TArraysegments; TArray originalSides; // The segs will lose some of these while working on them. + TArray subsectors; }; struct TriangleWorkData @@ -107,7 +98,6 @@ class FSectionCreator bool verbose = false; TMap> subsectormap; - TArray> rawsections; // list of unprocessed subsectors. Sector and mapsection can be retrieved from the elements so aren't stored. TArray sections; TArray triangles; @@ -185,16 +175,18 @@ public: // //========================================================================== - void CompileSections() + TArray < TArray> CompileSections() { TMap>::Pair *pair; TMap>::Iterator it(subsectormap); + TArray> 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 &list) + void CompileSections(TArray &list, TArray>&rawsections) { TArray sublist; TArray seglist; @@ -255,12 +247,15 @@ public: void MakeOutlines() { + auto rawsections = CompileSections(); TArray 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 §ion : sections) @@ -403,8 +398,14 @@ public: *sectionlines[i] = { nullptr, nullptr, nullptr, nullptr, -1, (int)sections.Size(), nullptr }; } } - - sections.Push({ sector, mapsec, hasminisegs, std::move(sectionlines), std::move(foundsides) }); + sections.Reserve(1); + auto §ion = 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 vertices; - TMap vertexmap; - bool perSubsector = false; - - TArray 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; - std::vector> polygon; - std::vector *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 §, VertexContainer &gen, int qualifier) - { - if (sect.segments.Size() < 3) return; - - // todo - } - - //============================================================================= - // - // - // - //============================================================================= - - - static void CreateVerticesForSection(FSection §ion, 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 §ion :sections) - { - CreateVerticesForSection( section, gen, true); - } - } - - TArray BuildVertices() - { - TArray verticesPerSector(level.sectors.Size(), true); - for (unsigned i=0; inumlines < 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; + std::vector> polygon; + std::vector *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 §, VertexContainer &gen, int qualifier) +{ + if (sect.segments.Size() < 3) return; + + // todo +} + +//============================================================================= +// +// +// +//============================================================================= + + +static void CreateVerticesForSection(FSection §ion, 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 §ion :sections) + { + CreateVerticesForSection( section, gen, true); + } +} + + +TArray BuildVertices() +{ + TArray verticesPerSector(level.sectors.Size(), true); + for (unsigned i=0; i struct THashTraits +{ + 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 vertices; + TMap vertexmap; + bool perSubsector = false; + + TArray 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; + +VertexContainers BuildVertices(); + + diff --git a/src/p_setup.cpp b/src/p_setup.cpp index a204144efb..15cbb0b543 100644 --- a/src/p_setup.cpp +++ b/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. diff --git a/src/r_data/renderinfo.cpp b/src/r_data/renderinfo.cpp index f50c32d518..bf59ec0c0a 100644 --- a/src/r_data/renderinfo.cpp +++ b/src/r_data/renderinfo.cpp @@ -532,8 +532,6 @@ static void PrepareSegs() void InitRenderInfo() { - CreateSections(level.sections); - PrepareSegs(); PrepareSectorData(); InitVertexData(); diff --git a/src/tarray.h b/src/tarray.h index 79b8853bd0..4a0d1570fc 100644 --- a/src/tarray.h +++ b/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 &other) {