diff options
Diffstat (limited to 'game')
| -rw-r--r-- | game/geoData.cpp | 340 | ||||
| -rw-r--r-- | game/geoData.h | 115 | ||||
| -rw-r--r-- | game/terrain.cpp | 65 | ||||
| -rw-r--r-- | game/terrain2.cpp | 221 | ||||
| -rw-r--r-- | game/terrain2.h | 93 |
5 files changed, 274 insertions, 560 deletions
diff --git a/game/geoData.cpp b/game/geoData.cpp index 34a1030..d32bf8c 100644 --- a/game/geoData.cpp +++ b/game/geoData.cpp @@ -1,214 +1,238 @@ #include "geoData.h" -#include "gfx/image.h" -#include <algorithm> -#include <array> -#include <cmath> -#include <cstddef> +#include <fstream> #include <glm/gtx/intersect.hpp> -#include <initializer_list> -#include <limits> #include <maths.h> -#include <random> -#include <ray.h> -#include <stb/stb_image.h> -#include <stdexcept> -#include <util.h> - -GeoData::GeoData(Limits l, float s) : - limit {std::move(l)}, size {(limit.second - limit.first) + 1}, scale {s}, nodes {[this]() { - return (static_cast<std::size_t>(size.x * size.y)); - }()} -{ -} -void -GeoData::generateRandom() +GeoData +GeoData::loadFromAsciiGrid(const std::filesystem::path & input) { - // We acknowledge this is terrible :) - - // Add hills - std::mt19937 gen(std::random_device {}()); - std::uniform_int_distribution<> rxpos(limit.first.x + 2, limit.second.x - 2), - rypos(limit.first.y + 2, limit.second.y - 2); - std::uniform_int_distribution<> rsize(10, 30); - std::uniform_real_distribution<float> rheight(1, 3); - for (int h = 0; h < 500;) { - const glm::ivec2 hpos {rxpos(gen), rypos(gen)}; - const glm::ivec2 hsize {rsize(gen), rsize(gen)}; - if (const auto lim1 = hpos - hsize; lim1.x > limit.first.x && lim1.y > limit.first.y) { - if (const auto lim2 = hpos + hsize; lim2.x < limit.second.x && lim2.y < limit.second.y) { - const auto height = rheight(gen); - const glm::ivec2 hsizesqrd {hsize.x * hsize.x, hsize.y * hsize.y}; - for (auto y = lim1.y; y < lim2.y; y += 1) { - for (auto x = lim1.x; x < lim2.x; x += 1) { - const auto dist {hpos - glm::ivec2 {x, y}}; - const glm::ivec2 distsqrd {dist.x * dist.x, dist.y * dist.y}; - const auto out {ratio(sq(x - hpos.x), sq(hsize.x)) + ratio(sq(y - hpos.y), sq(hsize.y))}; - if (out <= 1.0F) { - auto & node {nodes[at({x, y})]}; - const auto m {1.F / (7.F * out - 8.F) + 1.F}; - node.height += height * m; - } - } - } - h += 1; - } + size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0; + std::map<std::string_view, size_t *> properties { + {"ncols", &ncols}, + {"nrows", &nrows}, + {"xllcorner", &xllcorner}, + {"yllcorner", &yllcorner}, + {"cellsize", &cellsize}, + }; + std::ifstream f {input}; + while (!properties.empty()) { + std::string property; + f >> property; + f >> *properties.at(property); + properties.erase(property); + } + std::vector<VertexHandle> vertices; + vertices.reserve(ncols * nrows); + GeoData mesh; + mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()}; + mesh.upperExtent + = {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()}; + for (size_t row = 0; row < nrows; ++row) { + for (size_t col = 0; col < ncols; ++col) { + float height = 0; + f >> height; + mesh.upperExtent.z = std::max(mesh.upperExtent.z, height); + mesh.lowerExtent.z = std::min(mesh.lowerExtent.z, height); + vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height})); } } -} + if (!f.good()) { + throw std::runtime_error("Couldn't read terrain file"); + } + for (size_t row = 1; row < nrows; ++row) { + for (size_t col = 1; col < ncols; ++col) { + mesh.add_face({ + vertices[ncols * (row - 1) + (col - 1)], + vertices[ncols * (row - 0) + (col - 0)], + vertices[ncols * (row - 0) + (col - 1)], + }); + mesh.add_face({ + vertices[ncols * (row - 1) + (col - 1)], + vertices[ncols * (row - 1) + (col - 0)], + vertices[ncols * (row - 0) + (col - 0)], + }); + } + } + mesh.update_face_normals(); + mesh.update_vertex_normals(); -void -GeoData::loadFromImages(const std::filesystem::path & fileName, float scale_) -{ - const Image map {fileName.c_str(), STBI_grey}; - size = {map.width, map.height}; - limit = {{0, 0}, size - glm::uvec2 {1, 1}}; - const auto points {size.x * size.y}; - scale = scale_; - nodes.resize(points); - - std::transform(map.data.data(), map.data.data() + points, nodes.begin(), [](auto d) { - return Node {(d * 0.1F) - 1.5F}; - }); -} + return mesh; +}; -GeoData::Quad -GeoData::quad(glm::vec2 wcoord) const +GeoData +GeoData::createFlat(glm::vec2 lower, glm::vec2 upper, float h) { - constexpr static const std::array<glm::vec2, 4> corners {{{0, 0}, {0, 1}, {1, 0}, {1, 1}}}; - return transform_array(transform_array(corners, - [coord = (wcoord / scale)](const auto c) { - return glm::vec2 {std::floor(coord.x), std::floor(coord.y)} + c; - }), - [this](const auto c) { - return (c * scale) || nodes[at(c)].height; - }); -} + GeoData mesh; -glm::vec3 -GeoData::positionAt(const glm::vec2 wcoord) const -{ - const auto point {quad(wcoord)}; - const glm::vec2 frac = (wcoord - !point.front()) / scale; - auto edge = [&point, &frac](auto offset) { - return point[offset].z + ((point[offset + 2].z - point[offset].z) * frac.x); - }; - const auto heightFloor = edge(0U), heightCeil = edge(1U), - heightMid = heightFloor + ((heightCeil - heightFloor) * frac.y); + mesh.lowerExtent = lower ^ h; + mesh.upperExtent = upper ^ h; + + const auto ll = mesh.add_vertex({lower.x, lower.y, h}), lu = mesh.add_vertex({lower.x, upper.y, h}), + ul = mesh.add_vertex({upper.x, lower.y, h}), uu = mesh.add_vertex({upper.x, upper.y, h}); + + mesh.add_face(ll, uu, lu); + mesh.add_face(ll, ul, uu); - return wcoord || heightMid; + mesh.update_face_normals(); + mesh.update_vertex_normals(); + + return mesh; } -GeoData::RayTracer::RayTracer(glm::vec2 p0, glm::vec2 p1) : RayTracer {p0, p1, glm::abs(p1)} { } -GeoData::RayTracer::RayTracer(glm::vec2 p0, glm::vec2 p1, glm::vec2 d) : - RayTracer {p0, d, byAxis(p0, p1, d, 0), byAxis(p0, p1, d, 1)} +OpenMesh::FaceHandle +GeoData::findPoint(glm::vec2 p) const { + return findPoint(p, *faces_begin()); } -GeoData::RayTracer::RayTracer( - glm::vec2 p0, glm::vec2 d_, std::pair<float, float> xdata, std::pair<float, float> ydata) : - p {glm::floor(p0)}, - d {d_}, error {xdata.second - ydata.second}, inc {xdata.first, ydata.first} +GeoData::PointFace::PointFace(const glm::vec2 p, const GeoData * mesh) : PointFace {p, mesh, *mesh->faces_begin()} { } + +GeoData::PointFace::PointFace(const glm::vec2 p, const GeoData * mesh, FaceHandle start) : + PointFace {p, mesh->findPoint(p, start)} { } -std::pair<float, float> -GeoData::RayTracer::byAxis(glm::vec2 p0, glm::vec2 p1, glm::vec2 d, glm::length_t axis) +GeoData::FaceHandle +GeoData::PointFace::face(const GeoData * mesh, FaceHandle start) const { - using Limits = std::numeric_limits<typename glm::vec2::value_type>; - static_assert(Limits::has_infinity); - if (d[axis] == 0) { - return {0, Limits::infinity()}; - } - else if (p1[axis] > 0) { - return {1, (std::floor(p0[axis]) + 1.F - p0[axis]) * d[1 - axis]}; + if (_face.is_valid()) { + assert(mesh->triangleContainsPoint(point, _face)); + return _face; } else { - return {-1, (p0[axis] - std::floor(p0[axis])) * d[1 - axis]}; + return (_face = mesh->findPoint(point, start)); } } -glm::vec2 -GeoData::RayTracer::next() +GeoData::FaceHandle +GeoData::PointFace::face(const GeoData * mesh) const { - const glm::vec2 cur {p}; + return face(mesh, *mesh->faces_begin()); +} + +namespace { + [[nodiscard]] constexpr inline bool + pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2) + { + return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x); + } - static constexpr const glm::vec2 m {1, -1}; - const int axis = (error > 0) ? 1 : 0; - p[axis] += inc[axis]; - error += d[1 - axis] * m[axis]; + static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2})); + static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1})); + static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1})); + static_assert(pointLeftOfLine({1, 1}, {2, 1}, {1, 2})); - return cur; + [[nodiscard]] constexpr inline bool + linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2) + { + return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2) + && pointLeftOfLine(b2, a2, a1); + } + + static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1})); } -std::optional<glm::vec3> -GeoData::intersectRay(const Ray & ray) const +OpenMesh::FaceHandle +GeoData::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const { - if (glm::length(!ray.direction) <= 0) { - return {}; - } - RayTracer rt {ray.start / scale, ray.direction}; - while (true) { - const auto n {rt.next() * scale}; - try { - const auto point = quad(n); - for (auto offset : {0U, 1U}) { - glm::vec2 bary; - float distance; - if (glm::intersectRayTriangle(ray.start, ray.direction, point[offset], point[offset + 1], - point[offset + 2], bary, distance)) { - return point[offset] + ((point[offset + 1] - point[offset]) * bary[0]) - + ((point[offset + 2] - point[offset]) * bary[1]); + ConstFaceVertexIter vertices; + while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) { + for (auto next = cfh_iter(f); next.is_valid(); ++next) { + f = opposite_face_handle(*next); + if (f.is_valid()) { + const auto e1 = point(to_vertex_handle(*next)); + const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next))); + if (pointLeftOfLine(p, e1, e2)) { + break; } } - } - catch (std::range_error &) { - const auto rel = n / !ray.direction; - if (rel.x > 0 && rel.y > 0) { - return {}; - } + f.reset(); } } + return f; +} - return {}; +glm::vec3 +GeoData::positionAt(const PointFace & p) const +{ + glm::vec3 out {}; + Triangle<3> t {this, fv_range(p.face(this))}; + glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out); + return p.point ^ out[0]; } -unsigned int -GeoData::at(glm::ivec2 coord) const +[[nodiscard]] std::optional<glm::vec3> +GeoData::intersectRay(const Ray & ray) const { - if (coord.x < limit.first.x || coord.x > limit.second.x || coord.y < limit.first.y || coord.y > limit.second.y) { - throw std::range_error {"Coordinates outside GeoData limits"}; - } - const glm::uvec2 offset = coord - limit.first; - return offset.x + (offset.y * size.x); + return intersectRay(ray, findPoint(ray.start)); } -unsigned int -GeoData::at(int x, int y) const +[[nodiscard]] std::optional<glm::vec3> +GeoData::intersectRay(const Ray & ray, FaceHandle face) const { - return at({x, y}); + std::optional<glm::vec3> out; + walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) { + glm::vec2 bari {}; + float dist {}; + Triangle<3> t {this, fv_range(face)}; + if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) { + out = t * bari; + return true; + } + return false; + }); + return out; } -GeoData::Limits -GeoData::getLimit() const +void +GeoData::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const { - return limit; + walkUntil(from, to, [&op](const auto & fh) { + op(fh); + return false; + }); } -float -GeoData::getScale() const +void +GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const +{ + assert(from.face(this).is_valid()); // TODO replace with a boundary search + auto f = from.face(this); + FaceHandle previousFace; + while (f.is_valid() && !op(f)) { + for (auto next = cfh_iter(f); next.is_valid(); ++next) { + f = opposite_face_handle(*next); + if (f.is_valid() && f != previousFace) { + const auto e1 = point(to_vertex_handle(*next)); + const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next))); + if (linesCross(from.point, to, e1, e2)) { + previousFace = f; + break; + } + } + f.reset(); + } + } +} + +bool +GeoData::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c) { - return scale; + const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); + + return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0 + && det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0 + && det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0; } -glm::uvec2 -GeoData::getSize() const +bool +GeoData::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const { - return size; + return triangleContainsPoint(p, cfv_iter(face)); } -std::span<const GeoData::Node> -GeoData::getNodes() const +bool +GeoData::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const { - return nodes; + return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++)); } diff --git a/game/geoData.h b/game/geoData.h index f433a5c..3a4f98e 100644 --- a/game/geoData.h +++ b/game/geoData.h @@ -1,61 +1,94 @@ #pragma once -#include <array> +#include "collections.h" // IWYU pragma: keep IterableCollection +#include "ray.h" +#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh> #include <filesystem> -#include <glm/glm.hpp> +#include <glm/vec2.hpp> #include <optional> -#include <span> -#include <utility> -#include <vector> +#include <thirdparty/openmesh/glmcompat.h> -class Ray; +struct GeoDataTraits : public OpenMesh::DefaultTraits { + FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); + EdgeAttributes(OpenMesh::Attributes::Status); + VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); + HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); + using Point = glm::vec3; + using Normal = glm::vec3; +}; + +class GeoData : public OpenMesh::TriMesh_ArrayKernelT<GeoDataTraits> { +private: + GeoData() = default; -class GeoData { public: - struct Node { - float height {-1.5F}; - }; - using Quad = std::array<glm::vec3, 4>; + static GeoData loadFromAsciiGrid(const std::filesystem::path &); + static GeoData createFlat(glm::vec2 lower, glm::vec2, float h); - using Limits = std::pair<glm::ivec2, glm::ivec2>; + struct PointFace { + // NOLINTNEXTLINE(hicpp-explicit-conversions) + PointFace(const glm::vec2 p) : point {p} { } - explicit GeoData(Limits limit, float scale = 10.F); + PointFace(const glm::vec2 p, FaceHandle face) : point {p}, _face {face} { } - void generateRandom(); - void loadFromImages(const std::filesystem::path &, float scale); + PointFace(const glm::vec2 p, const GeoData *); + PointFace(const glm::vec2 p, const GeoData *, FaceHandle start); - [[nodiscard]] glm::vec3 positionAt(glm::vec2) const; - [[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const; + const glm::vec2 point; + [[nodiscard]] FaceHandle face(const GeoData *) const; + [[nodiscard]] FaceHandle face(const GeoData *, FaceHandle start) const; - [[nodiscard]] unsigned int at(glm::ivec2) const; - [[nodiscard]] unsigned int at(int x, int y) const; - [[nodiscard]] Quad quad(glm::vec2) const; + [[nodiscard]] bool + isLocated() const + { + return _face.is_valid(); + } - [[nodiscard]] Limits getLimit() const; - [[nodiscard]] glm::uvec2 getSize() const; - [[nodiscard]] float getScale() const; - [[nodiscard]] std::span<const Node> getNodes() const; + private: + mutable FaceHandle _face {}; + }; - class RayTracer { - public: - RayTracer(glm::vec2 p0, glm::vec2 p1); + template<glm::length_t Dim> struct Triangle : public glm::vec<3, glm::vec<Dim, glm::vec2::value_type>> { + using base = glm::vec<3, glm::vec<Dim, glm::vec2::value_type>>; + using base::base; - glm::vec2 next(); + template<IterableCollection Range> Triangle(const GeoData * m, Range range) + { + assert(std::distance(range.begin(), range.end()) == 3); + std::transform(range.begin(), range.end(), &base::operator[](0), [m](auto vh) { + return m->point(vh); + }); + } - private: - RayTracer(glm::vec2 p0, glm::vec2 p1, glm::vec2 d); - RayTracer(glm::vec2 p0, glm::vec2 d, std::pair<float, float>, std::pair<float, float>); - static std::pair<float, float> byAxis(glm::vec2 p0, glm::vec2 p1, glm::vec2 d, glm::length_t); - - glm::vec2 p; - const glm::vec2 d; - float error; - glm::vec2 inc; + glm::vec<Dim, glm::vec2::value_type> + operator*(glm::vec2 bari) const + { + const auto & t {*this}; + return t[0] + ((t[1] - t[0]) * bari.x) + ((t[2] - t[1]) * bari.y); + } }; + [[nodiscard]] FaceHandle findPoint(glm::vec2) const; + [[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const; + + [[nodiscard]] glm::vec3 positionAt(const PointFace &) const; + [[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const; + [[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &, FaceHandle start) const; + + void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const; + void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const; + + [[nodiscard]] auto + getExtents() const + { + return std::tie(lowerExtent, upperExtent); + } + protected: - Limits limit {}; // Base grid limits first(x,y) -> second(x,y) - glm::uvec2 size {}; - float scale {1}; - std::vector<Node> nodes; + [[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2); + [[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const; + [[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const; + +private: + glm::vec3 lowerExtent {}, upperExtent {}; }; diff --git a/game/terrain.cpp b/game/terrain.cpp index f3bec1e..5bb8abd 100644 --- a/game/terrain.cpp +++ b/game/terrain.cpp @@ -2,7 +2,6 @@ #include "game/geoData.h" #include "gfx/models/texture.h" #include <algorithm> -#include <array> #include <cache.h> #include <cstddef> #include <filesystem> @@ -18,8 +17,8 @@ #include <utility> #include <vector> -Terrain::Terrain(std::shared_ptr<GeoData> gd) : - geoData {std::move(gd)}, grass {Texture::cachedTexture.get("grass.png")}, +Terrain::Terrain(std::shared_ptr<GeoData> tm) : + geoData {std::move(tm)}, grass {Texture::cachedTexture.get("grass.png")}, water {Texture::cachedTexture.get("water.png")} { generateMeshes(); @@ -29,51 +28,23 @@ void Terrain::generateMeshes() { std::vector<unsigned int> indices; - const auto isize = geoData->getSize() - glm::uvec2 {1, 1}; - indices.reserve(static_cast<std::size_t>(isize.x * isize.y) * 6); - - const auto limit = geoData->getLimit(); - // Indices - constexpr std::array<glm::ivec2, 6> indices_offsets {{ - {0, 0}, - {1, 0}, - {1, 1}, - {0, 0}, - {1, 1}, - {0, 1}, - }}; - for (auto y = limit.first.y; y < limit.second.y; y += 1) { - for (auto x = limit.first.x; x < limit.second.x; x += 1) { - std::transform(indices_offsets.begin(), indices_offsets.end(), std::back_inserter(indices), - [this, x, y](const auto off) { - return geoData->at(x + off.x, y + off.y); - }); - } - } - - const auto nodes = geoData->getNodes(); - const auto scale = geoData->getScale(); + indices.reserve(geoData->n_faces() * 3); std::vector<Vertex> vertices; - vertices.reserve(nodes.size()); - // Positions - for (auto y = limit.first.y; y <= limit.second.y; y += 1) { - for (auto x = limit.first.x; x <= limit.second.x; x += 1) { - const glm::vec2 xy {x, y}; - vertices.emplace_back((xy * scale) ^ nodes[geoData->at(x, y)].height, xy, ::up); - } - } - // Normals - const glm::uvec2 size = geoData->getSize(); - for (auto y = limit.first.y + 1; y < limit.second.y; y += 1) { - for (auto x = limit.first.x + 1; x < limit.second.x; x += 1) { - const auto n {geoData->at(x, y)}; - const auto a = vertices[n - 1].pos; - const auto b = vertices[n - size.x].pos; - const auto c = vertices[n + 1].pos; - const auto d = vertices[n + size.x].pos; - vertices[n].normal = -glm::normalize(glm::cross(b - d, a - c)); - } - } + vertices.reserve(geoData->n_vertices()); + std::map<GeoData::VertexHandle, size_t> vertexIndex; + std::transform(geoData->vertices_begin(), geoData->vertices_end(), std::back_inserter(vertices), + [this, &vertexIndex](const GeoData::VertexHandle v) { + vertexIndex.emplace(v, vertexIndex.size()); + const glm::vec3 p = geoData->point(v); + return Vertex {p, p / 10.F, geoData->normal(v)}; + }); + std::for_each( + geoData->faces_begin(), geoData->faces_end(), [this, &vertexIndex, &indices](const GeoData::FaceHandle f) { + std::transform(geoData->fv_begin(f), geoData->fv_end(f), std::back_inserter(indices), + [&vertexIndex](const GeoData::VertexHandle v) { + return vertexIndex[v]; + }); + }); meshes.create<Mesh>(vertices, indices); } diff --git a/game/terrain2.cpp b/game/terrain2.cpp deleted file mode 100644 index 0e8b78e..0000000 --- a/game/terrain2.cpp +++ /dev/null @@ -1,221 +0,0 @@ -#include "terrain2.h" -#include <fstream> -#include <glm/gtx/intersect.hpp> -#include <maths.h> - -TerrainMesh -TerrainMesh::loadFromAsciiGrid(const std::filesystem::path & input) -{ - size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0; - std::map<std::string_view, size_t *> properties { - {"ncols", &ncols}, - {"nrows", &nrows}, - {"xllcorner", &xllcorner}, - {"yllcorner", &yllcorner}, - {"cellsize", &cellsize}, - }; - std::ifstream f {input}; - while (!properties.empty()) { - std::string property; - f >> property; - f >> *properties.at(property); - properties.erase(property); - } - std::vector<VertexHandle> vertices; - vertices.reserve(ncols * nrows); - TerrainMesh mesh; - mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()}; - mesh.upperExtent - = {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()}; - for (size_t row = 0; row < nrows; ++row) { - for (size_t col = 0; col < ncols; ++col) { - float height = 0; - f >> height; - mesh.upperExtent.z = std::max(mesh.upperExtent.z, height); - mesh.lowerExtent.z = std::min(mesh.lowerExtent.z, height); - vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height})); - } - } - if (!f.good()) { - throw std::runtime_error("Couldn't read terrain file"); - } - for (size_t row = 1; row < nrows; ++row) { - for (size_t col = 1; col < ncols; ++col) { - mesh.add_face({ - vertices[ncols * (row - 1) + (col - 1)], - vertices[ncols * (row - 0) + (col - 0)], - vertices[ncols * (row - 0) + (col - 1)], - }); - mesh.add_face({ - vertices[ncols * (row - 1) + (col - 1)], - vertices[ncols * (row - 1) + (col - 0)], - vertices[ncols * (row - 0) + (col - 0)], - }); - } - } - mesh.update_face_normals(); - mesh.update_vertex_normals(); - - return mesh; -}; - -OpenMesh::FaceHandle -TerrainMesh::findPoint(glm::vec2 p) const -{ - return findPoint(p, *faces_begin()); -} - -TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh) : - PointFace {p, mesh, *mesh->faces_begin()} -{ -} - -TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh, FaceHandle start) : - PointFace {p, mesh->findPoint(p, start)} -{ -} - -TerrainMesh::FaceHandle -TerrainMesh::PointFace::face(const TerrainMesh * mesh, FaceHandle start) const -{ - if (_face.is_valid()) { - assert(mesh->triangleContainsPoint(point, _face)); - return _face; - } - else { - return (_face = mesh->findPoint(point, start)); - } -} - -TerrainMesh::FaceHandle -TerrainMesh::PointFace::face(const TerrainMesh * mesh) const -{ - return face(mesh, *mesh->faces_begin()); -} - -namespace { - [[nodiscard]] constexpr inline bool - pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2) - { - return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x); - } - - static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2})); - static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1})); - static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1})); - static_assert(pointLeftOfLine({1, 1}, {2, 1}, {1, 2})); - - [[nodiscard]] constexpr inline bool - linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2) - { - return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2) - && pointLeftOfLine(b2, a2, a1); - } - - static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1})); -} - -OpenMesh::FaceHandle -TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const -{ - ConstFaceVertexIter vertices; - while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) { - for (auto next = cfh_iter(f); next.is_valid(); ++next) { - f = opposite_face_handle(*next); - if (f.is_valid()) { - const auto e1 = point(to_vertex_handle(*next)); - const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next))); - if (pointLeftOfLine(p, e1, e2)) { - break; - } - } - f.reset(); - } - } - return f; -} - -glm::vec3 -TerrainMesh::positionAt(const PointFace & p) const -{ - glm::vec3 out {}; - Triangle<3> t {this, fv_range(p.face(this))}; - glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out); - return p.point ^ out[0]; -} - -[[nodiscard]] std::optional<glm::vec3> -TerrainMesh::intersectRay(const Ray & ray) const -{ - return intersectRay(ray, findPoint(ray.start)); -} - -[[nodiscard]] std::optional<glm::vec3> -TerrainMesh::intersectRay(const Ray & ray, FaceHandle face) const -{ - std::optional<glm::vec3> out; - walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) { - glm::vec2 bari {}; - float dist {}; - Triangle<3> t {this, fv_range(face)}; - if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) { - out = t * bari; - return true; - } - return false; - }); - return out; -} - -void -TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const -{ - walkUntil(from, to, [&op](const auto & fh) { - op(fh); - return false; - }); -} - -void -TerrainMesh::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const -{ - assert(from.face(this).is_valid()); // TODO replace with a boundary search - auto f = from.face(this); - FaceHandle previousFace; - while (f.is_valid() && !op(f)) { - for (auto next = cfh_iter(f); next.is_valid(); ++next) { - f = opposite_face_handle(*next); - if (f.is_valid() && f != previousFace) { - const auto e1 = point(to_vertex_handle(*next)); - const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next))); - if (linesCross(from.point, to, e1, e2)) { - previousFace = f; - break; - } - } - f.reset(); - } - } -} - -bool -TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c) -{ - const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); - - return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0 - && det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0 - && det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0; -} - -bool -TerrainMesh::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const -{ - return triangleContainsPoint(p, cfv_iter(face)); -} - -bool -TerrainMesh::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const -{ - return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++)); -} diff --git a/game/terrain2.h b/game/terrain2.h deleted file mode 100644 index eda56d0..0000000 --- a/game/terrain2.h +++ /dev/null @@ -1,93 +0,0 @@ -#pragma once - -#include "collections.h" // IWYU pragma: keep IterableCollection -#include "ray.h" -#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh> -#include <filesystem> -#include <glm/vec2.hpp> -#include <optional> -#include <thirdparty/openmesh/glmcompat.h> - -struct TerrainTraits : public OpenMesh::DefaultTraits { - FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); - EdgeAttributes(OpenMesh::Attributes::Status); - VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); - HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status); - using Point = glm::vec3; - using Normal = glm::vec3; -}; - -class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> { -private: - TerrainMesh() = default; - -public: - static TerrainMesh loadFromAsciiGrid(const std::filesystem::path &); - - struct PointFace { - // NOLINTNEXTLINE(hicpp-explicit-conversions) - PointFace(const glm::vec2 p) : point {p} { } - - PointFace(const glm::vec2 p, FaceHandle face) : point {p}, _face {face} { } - - PointFace(const glm::vec2 p, const TerrainMesh *); - PointFace(const glm::vec2 p, const TerrainMesh *, FaceHandle start); - - const glm::vec2 point; - [[nodiscard]] FaceHandle face(const TerrainMesh *) const; - [[nodiscard]] FaceHandle face(const TerrainMesh *, FaceHandle start) const; - - [[nodiscard]] bool - isLocated() const - { - return _face.is_valid(); - } - - private: - mutable FaceHandle _face {}; - }; - - template<glm::length_t Dim> struct Triangle : public glm::vec<3, glm::vec<Dim, glm::vec2::value_type>> { - using base = glm::vec<3, glm::vec<Dim, glm::vec2::value_type>>; - using base::base; - - template<IterableCollection Range> Triangle(const TerrainMesh * m, Range range) - { - assert(std::distance(range.begin(), range.end()) == 3); - std::transform(range.begin(), range.end(), &base::operator[](0), [m](auto vh) { - return m->point(vh); - }); - } - - glm::vec<Dim, glm::vec2::value_type> - operator*(glm::vec2 bari) const - { - const auto & t {*this}; - return t[0] + ((t[1] - t[0]) * bari.x) + ((t[2] - t[1]) * bari.y); - } - }; - - [[nodiscard]] FaceHandle findPoint(glm::vec2) const; - [[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const; - - [[nodiscard]] glm::vec3 positionAt(const PointFace &) const; - [[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const; - [[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &, FaceHandle start) const; - - void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const; - void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const; - - [[nodiscard]] auto - getExtents() const - { - return std::tie(lowerExtent, upperExtent); - } - -protected: - [[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2); - [[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const; - [[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const; - -private: - glm::vec3 lowerExtent {}, upperExtent {}; -}; |