summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--game/network/link.cpp65
-rw-r--r--game/network/link.h7
-rw-r--r--game/network/network.cpp81
-rw-r--r--game/network/network.h27
-rw-r--r--game/network/network.impl.h37
-rw-r--r--game/network/rail.cpp86
6 files changed, 158 insertions, 145 deletions
diff --git a/game/network/link.cpp b/game/network/link.cpp
index c84524c..b8ffee2 100644
--- a/game/network/link.cpp
+++ b/game/network/link.cpp
@@ -5,37 +5,43 @@
#include <ray.h>
#include <tuple>
-Link::Link(End a, End b, float l) : ends {{std::move(a), std::move(b)}}, length {l} { }
+Link::Link(End endA, End endB, float len) : ends {{std::move(endA), std::move(endB)}}, length {len} { }
-LinkCurve::LinkCurve(GlobalPosition3D c, RelativeDistance r, Arc a) : centreBase {c}, radius {r}, arc {std::move(a)} { }
+LinkCurve::LinkCurve(GlobalPosition3D centre, RelativeDistance radius, Arc arc) :
+ centreBase {centre}, radius {radius}, arc {std::move(arc)}
+{
+}
bool
-operator<(const GlobalPosition3D & a, const GlobalPosition3D & b)
+operator<(const GlobalPosition3D & left, const GlobalPosition3D & right)
{
// NOLINTNEXTLINE(hicpp-use-nullptr,modernize-use-nullptr)
- return std::tie(a.x, a.y, a.z) < std::tie(b.x, b.y, b.z);
+ return std::tie(left.x, left.y, left.z) < std::tie(right.x, right.y, right.z);
}
bool
-operator<(const Node & a, const Node & b)
+operator<(const Node & left, const Node & right)
{
- return a.pos < b.pos;
+ return left.pos < right.pos;
}
Location
LinkStraight::positionAt(RelativeDistance dist, unsigned char start) const
{
- const auto es {std::make_pair(ends[start].node.get(), ends[1 - start].node.get())};
- const RelativePosition3D diff {es.second->pos - es.first->pos};
- const auto dir {glm::normalize(diff)};
- return Location {es.first->pos + (vehiclePositionOffset() + dir * dist), {vector_pitch(dir), vector_yaw(dir), 0}};
+ const auto endNodes = std::make_pair(ends[start].node.get(), ends[1 - start].node.get());
+ const auto diff = ::difference(endNodes.second->pos, endNodes.first->pos);
+ const auto directionVector = glm::normalize(diff);
+ return Location {
+ .pos = endNodes.first->pos + (vehiclePositionOffset() + directionVector * dist),
+ .rot = {vector_pitch(directionVector), vector_yaw(directionVector), 0},
+ };
}
bool
LinkStraight::intersectRay(const Ray<GlobalPosition3D> & ray) const
{
- return ray.passesCloseToEdges(
- std::array {GlobalPosition3D {ends.front().node->pos}, GlobalPosition3D {ends.back().node->pos}}, 1000);
+ static constexpr auto PROXIMITY = 1'000;
+ return ray.passesCloseToEdges(std::array {ends.front().node->pos, ends.back().node->pos}, PROXIMITY);
}
std::vector<GlobalPosition3D>
@@ -55,33 +61,36 @@ LinkStraight::getBase(RelativeDistance width) const
Location
LinkCurve::positionAt(float dist, unsigned char start) const
{
- static constexpr std::array<float, 2> dirOffset {half_pi, -half_pi};
- const auto frac {dist / length};
- const auto es {std::make_pair(ends[start].node.get(), ends[1 - start].node.get())};
- const auto as {std::make_pair(arc[start], arc[1 - start])};
- const auto ang {as.first + ((as.second - as.first) * frac)};
- const auto relPos {(sincos(ang) || 0.F) * radius};
- const auto relClimb {vehiclePositionOffset()
+ static constexpr std::array DIR_OFFSET {half_pi, -half_pi};
+ const auto frac = dist / length;
+ const auto endNodes = std::make_pair(ends[start].node.get(), ends[1 - start].node.get());
+ const auto arcEndAngles = std::make_pair(arc[start], arc[1 - start]);
+ const auto ang = glm::mix(arcEndAngles.first, arcEndAngles.second, frac);
+ const auto relPos = (sincos(ang) || 0.F) * radius;
+ const auto relClimb = vehiclePositionOffset()
+ RelativePosition3D {0, 0,
- static_cast<RelativeDistance>(es.first->pos.z - centreBase.z)
- + (static_cast<RelativeDistance>(es.second->pos.z - es.first->pos.z) * frac)}};
- const auto pitch {vector_pitch(difference(es.second->pos, es.first->pos) / length)};
- return Location {GlobalPosition3D(relPos + relClimb) + centreBase, {pitch, normalize(ang + dirOffset[start]), 0}};
+ static_cast<RelativeDistance>(endNodes.first->pos.z - centreBase.z)
+ + (static_cast<RelativeDistance>(endNodes.second->pos.z - endNodes.first->pos.z) * frac)};
+ const auto pitch {vector_pitch(difference(endNodes.second->pos, endNodes.first->pos) / length)};
+ return Location {
+ .pos = GlobalPosition3D(relPos + relClimb) + centreBase,
+ .rot = {pitch, normalize(ang + DIR_OFFSET[start]), 0},
+ };
}
bool
LinkCurve::intersectRay(const Ray<GlobalPosition3D> & ray) const
{
- const auto & e0p {ends[0].node->pos};
- const auto & e1p {ends[1].node->pos};
+ const auto e0p = ends[0].node->pos.z;
+ const auto e1p = ends[1].node->pos.z;
const auto slength = round_frac(length / 2.F, 5.F);
const auto segs = std::round(15.F * slength / std::pow(radius, 0.7F));
- const auto step {glm::vec<2, RelativeDistance> {arc.length(), e1p.z - e0p.z} / segs};
+ const auto step {glm::vec<2, RelativeDistance> {arc.length(), e1p - e0p} / segs};
auto segCount = static_cast<std::size_t>(std::lround(segs)) + 1;
std::vector<GlobalPosition3D> points;
points.reserve(segCount);
- for (std::remove_const_t<decltype(step)> swing = {arc.first, centreBase.z - e0p.z}; segCount;
+ for (std::remove_const_t<decltype(step)> swing = {arc.first, centreBase.z - e0p}; segCount;
swing += step, --segCount) {
points.emplace_back(centreBase + ((sincos(swing.x) * radius) || swing.y));
}
@@ -94,7 +103,7 @@ LinkCurve::getBase(RelativeDistance width) const
const auto start = ends.front().node->pos;
const auto end = ends.back().node->pos;
const auto segs = std::ceil(std::sqrt(radius) * 0.02F * arc.length());
- const auto step {glm::vec<2, RelativeDistance> {arc.length(), end.z - start.z} / segs};
+ const auto step = glm::vec<2, RelativeDistance> {arc.length(), end.z - start.z} / segs;
auto segCount = static_cast<size_t>(segs) + 1;
std::vector<GlobalPosition3D> out;
diff --git a/game/network/link.h b/game/network/link.h
index 59bbb65..0b58558 100644
--- a/game/network/link.h
+++ b/game/network/link.h
@@ -16,7 +16,7 @@ template<typename> class Ray;
// it has location
class Node : public StdTypeDefs<Node> {
public:
- explicit Node(GlobalPosition3D p) noexcept : pos(p) { };
+ explicit Node(GlobalPosition3D position) noexcept : pos(position) { };
virtual ~Node() noexcept = default;
NO_COPY(Node);
NO_MOVE(Node);
@@ -35,6 +35,7 @@ public:
struct End {
Node::Ptr node;
float dir;
+ // NOLINTNEXTLINE(readability-redundant-member-init) don't require client to empty initialise this
Nexts nexts {};
};
@@ -58,8 +59,8 @@ protected:
}
};
-bool operator<(const GlobalPosition3D & a, const GlobalPosition3D & b);
-bool operator<(const Node & a, const Node & b);
+bool operator<(const GlobalPosition3D &, const GlobalPosition3D &);
+bool operator<(const Node &, const Node &);
class LinkStraight : public virtual Link {
public:
diff --git a/game/network/network.cpp b/game/network/network.cpp
index e67942f..a39a66c 100644
--- a/game/network/network.cpp
+++ b/game/network/network.cpp
@@ -8,8 +8,8 @@
#include <stdexcept>
#include <utility>
-Network::Network(const std::string & tn) :
- texture {std::make_shared<Texture>(tn,
+Network::Network(const std::string & textureName) :
+ texture {std::make_shared<Texture>(textureName,
TextureOptions {
.minFilter = GL_NEAREST_MIPMAP_LINEAR,
})}
@@ -25,19 +25,18 @@ Network::nodeAt(GlobalPosition3D pos)
Network::NodeInsertion
Network::newNodeAt(GlobalPosition3D pos)
{
- if (auto [n, i] = candidateNodeAt(pos); i == NodeIs::NotInNetwork) {
- return {*nodes.insert(std::move(n)).first, i};
- }
- else {
- return {std::move(n), NodeIs::InNetwork};
+ auto [node, inNetwork] = candidateNodeAt(pos);
+ if (inNetwork == NodeIs::NotInNetwork) {
+ return {*nodes.insert(std::move(node)).first, inNetwork};
}
+ return {std::move(node), NodeIs::InNetwork};
}
Node::Ptr
Network::findNodeAt(GlobalPosition3D pos) const
{
- if (const auto n = nodes.find(pos); n != nodes.end()) {
- return *n;
+ if (const auto node = nodes.find(pos); node != nodes.end()) {
+ return *node;
}
return {};
}
@@ -45,8 +44,8 @@ Network::findNodeAt(GlobalPosition3D pos) const
Network::NodeInsertion
Network::candidateNodeAt(GlobalPosition3D pos) const
{
- if (const auto n = nodes.find(pos); n != nodes.end()) {
- return {*n, NodeIs::InNetwork};
+ if (const auto node = nodes.find(pos); node != nodes.end()) {
+ return {*node, NodeIs::InNetwork};
}
return {std::make_shared<Node>(pos), NodeIs::NotInNetwork};
}
@@ -54,12 +53,13 @@ Network::candidateNodeAt(GlobalPosition3D pos) const
Node::Ptr
Network::intersectRayNodes(const Ray<GlobalPosition3D> & ray) const
{
+ static constexpr auto MIN_DISTANCE = 2000;
// Click within 2m of a node
if (const auto node = std::find_if(nodes.begin(), nodes.end(),
[&ray](const Node::Ptr & node) {
GlobalPosition3D ipos;
Normal3D inorm;
- return ray.intersectSphere(node->pos, 2000, ipos, inorm);
+ return ray.intersectSphere(node->pos, MIN_DISTANCE, ipos, inorm);
});
node != nodes.end()) {
return *node;
@@ -68,14 +68,14 @@ Network::intersectRayNodes(const Ray<GlobalPosition3D> & ray) const
}
void
-Network::joinLinks(const Link::Ptr & l, const Link::Ptr & ol)
+Network::joinLinks(const Link::Ptr & link, const Link::Ptr & oldLink)
{
- if (l != ol) {
- for (const auto oe : {0U, 1U}) {
- for (const auto te : {0U, 1U}) {
- if (l->ends[te].node == ol->ends[oe].node) {
- l->ends[te].nexts.emplace_back(ol, oe);
- ol->ends[oe].nexts.emplace_back(l, te);
+ if (link != oldLink) {
+ for (const auto oldLinkEnd : {0U, 1U}) {
+ for (const auto linkEnd : {0U, 1U}) {
+ if (link->ends[linkEnd].node == oldLink->ends[oldLinkEnd].node) {
+ link->ends[linkEnd].nexts.emplace_back(oldLink, oldLinkEnd);
+ oldLink->ends[oldLinkEnd].nexts.emplace_back(link, linkEnd);
}
}
}
@@ -93,7 +93,7 @@ Network::routeFromTo(const Link::End & start, GlobalPosition3D dest) const
}
Link::Nexts
-Network::routeFromTo(const Link::End & end, const Node::Ptr & dest) const
+Network::routeFromTo(const Link::End & end, const Node::Ptr & dest)
{
return RouteWalker().findRouteTo(end, dest);
}
@@ -102,11 +102,11 @@ GenCurveDef
Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir)
{
const auto diff = difference(end, start);
- const auto vy {vector_yaw(diff)};
+ const auto yaw = vector_yaw(diff);
const auto dir = pi + startDir;
- const auto flatStart {start.xy()}, flatEnd {end.xy()};
- const auto n2ed {(vy * 2) - dir - pi};
- const auto centre {find_arc_centre(flatStart, dir, flatEnd, n2ed)};
+ const auto flatStart = start.xy(), flatEnd = end.xy();
+ const auto n2ed = (yaw * 2) - dir - pi;
+ const auto centre = find_arc_centre(flatStart, dir, flatEnd, n2ed);
if (centre.second) { // right hand arc
return {end, start, centre.first};
@@ -121,24 +121,23 @@ Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & en
endDir += pi;
const auto flatStart {start.xy()}, flatEnd {end.xy()};
auto midheight = [&](auto mid) {
- const auto sm = ::distance<2>(flatStart, mid);
- const auto em = ::distance<2>(flatEnd, mid);
- return start.z + GlobalDistance(RelativeDistance(end.z - start.z) * (sm / (sm + em)));
+ const auto startToMid = ::distance<2>(flatStart, mid);
+ const auto endToMid = ::distance<2>(flatEnd, mid);
+ return start.z + GlobalDistance(RelativeDistance(end.z - start.z) * (startToMid / (startToMid + endToMid)));
};
- if (const auto radii = find_arcs_radius(flatStart, startDir, flatEnd, endDir); radii.first < radii.second) {
- const auto radius {radii.first};
- const auto c1 = flatStart + (sincos(startDir + half_pi) * radius);
- const auto c2 = flatEnd + (sincos(endDir + half_pi) * radius);
- const auto mid = (c1 + c2) / 2;
- const auto midh = mid || midheight(mid);
- return {{start, midh, c1}, {end, midh, c2}};
- }
- else {
- const auto radius {radii.second};
- const auto c1 = flatStart + (sincos(startDir - half_pi) * radius);
- const auto c2 = flatEnd + (sincos(endDir - half_pi) * radius);
- const auto mid = (c1 + c2) / 2;
+ const auto radii = find_arcs_radius(flatStart, startDir, flatEnd, endDir);
+ if (radii.first < radii.second) {
+ const auto radius = radii.first;
+ const auto centre1 = flatStart + (sincos(startDir + half_pi) * radius);
+ const auto centre2 = flatEnd + (sincos(endDir + half_pi) * radius);
+ const auto mid = (centre1 + centre2) / 2;
const auto midh = mid || midheight(mid);
- return {{midh, start, c1}, {midh, end, c2}};
+ return {{start, midh, centre1}, {end, midh, centre2}};
}
+ const auto radius = radii.second;
+ const auto centre1 = flatStart + (sincos(startDir - half_pi) * radius);
+ const auto centre2 = flatEnd + (sincos(endDir - half_pi) * radius);
+ const auto mid = (centre1 + centre2) / 2;
+ const auto midh = mid || midheight(mid);
+ return {{midh, start, centre1}, {midh, end, centre2}};
}
diff --git a/game/network/network.h b/game/network/network.h
index 73c3788..4f5d2b0 100644
--- a/game/network/network.h
+++ b/game/network/network.h
@@ -18,7 +18,7 @@ struct Surface;
class GeoData;
template<typename> class Ray;
-template<size_t... n> using GenDef = std::tuple<glm::vec<n, GlobalDistance>...>;
+template<size_t... N> using GenDef = std::tuple<glm::vec<N, GlobalDistance>...>;
using GenCurveDef = GenDef<3, 3, 2>;
class Network {
@@ -30,7 +30,7 @@ public:
[[nodiscard]] Node::Ptr findNodeAt(GlobalPosition3D) const;
[[nodiscard]] Node::Ptr nodeAt(GlobalPosition3D);
- enum class NodeIs { InNetwork, NotInNetwork };
+ enum class NodeIs : uint8_t { InNetwork, NotInNetwork };
using NodeInsertion = std::pair<Node::Ptr, NodeIs>;
[[nodiscard]] NodeInsertion newNodeAt(GlobalPosition3D);
[[nodiscard]] NodeInsertion candidateNodeAt(GlobalPosition3D) const;
@@ -38,7 +38,7 @@ public:
[[nodiscard]] virtual Node::Ptr intersectRayNodes(const Ray<GlobalPosition3D> &) const;
[[nodiscard]] Link::Nexts routeFromTo(const Link::End &, GlobalPosition3D) const;
- [[nodiscard]] Link::Nexts routeFromTo(const Link::End &, const Node::Ptr &) const;
+ [[nodiscard]] static Link::Nexts routeFromTo(const Link::End &, const Node::Ptr &);
virtual Link::CCollection candidateStraight(GlobalPosition3D, GlobalPosition3D) = 0;
virtual Link::CCollection candidateJoins(GlobalPosition3D, GlobalPosition3D) = 0;
@@ -53,7 +53,7 @@ public:
[[nodiscard]] virtual RelativeDistance getBaseWidth() const = 0;
protected:
- static void joinLinks(const Link::Ptr & l, const Link::Ptr & ol);
+ static void joinLinks(const Link::Ptr & link, const Link::Ptr & oldLink);
static GenCurveDef genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir);
static std::pair<GenCurveDef, GenCurveDef> genCurveDef(
const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir, float endDir);
@@ -80,34 +80,33 @@ protected:
SharedCollection<T> links;
void joinLinks(const Link::Ptr &) const;
-protected:
[[nodiscard]] Link::Ptr intersectRayLinks(const Ray<GlobalPosition3D> &) const override;
public:
template<typename L, typename... Params>
std::shared_ptr<L>
- candidateLink(GlobalPosition3D a, GlobalPosition3D b, Params &&... params)
+ candidateLink(GlobalPosition3D positionA, GlobalPosition3D positionB, Params &&... params)
requires std::is_base_of_v<T, L>
{
- const auto node1 = candidateNodeAt(a).first, node2 = candidateNodeAt(b).first;
+ const auto node1 = candidateNodeAt(positionA).first, node2 = candidateNodeAt(positionB).first;
return std::make_shared<L>(*this, node1, node2, std::forward<Params>(params)...);
}
template<typename L, typename... Params>
std::shared_ptr<L>
- addLink(GlobalPosition3D a, GlobalPosition3D b, Params &&... params)
+ addLink(GlobalPosition3D positionA, GlobalPosition3D positionB, Params &&... params)
requires std::is_base_of_v<T, L>
{
- const auto node1 = nodeAt(a), node2 = nodeAt(b);
- auto l {links.template create<L>(*this, node1, node2, std::forward<Params>(params)...)};
- joinLinks(l);
- return l;
+ const auto node1 = nodeAt(positionA), node2 = nodeAt(positionB);
+ auto newLink = links.template create<L>(*this, node1, node2, std::forward<Params>(params)...);
+ joinLinks(newLink);
+ return std::move(newLink);
}
- Link::CCollection candidateStraight(GlobalPosition3D n1, GlobalPosition3D n2) override;
+ Link::CCollection candidateStraight(GlobalPosition3D, GlobalPosition3D) override;
Link::CCollection candidateJoins(GlobalPosition3D, GlobalPosition3D) override;
Link::CCollection candidateExtend(GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection addStraight(const GeoData *, GlobalPosition3D n1, GlobalPosition3D n2) override;
+ Link::CCollection addStraight(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
Link::CCollection addJoins(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
Link::CCollection addExtend(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
diff --git a/game/network/network.impl.h b/game/network/network.impl.h
index 294f696..e339922 100644
--- a/game/network/network.impl.h
+++ b/game/network/network.impl.h
@@ -6,10 +6,10 @@
template<typename T, typename... Links>
void
-NetworkOf<T, Links...>::joinLinks(const Link::Ptr & l) const
+NetworkOf<T, Links...>::joinLinks(const Link::Ptr & link) const
{
- for (const auto & ol : links) {
- Network::joinLinks(l, ol);
+ for (const auto & oldLink : links) {
+ Network::joinLinks(link, oldLink);
}
}
@@ -32,11 +32,11 @@ template<typename T, typename... Links>
float
NetworkOf<T, Links...>::findNodeDirection(Node::AnyCPtr n) const
{
- for (const auto & l : links) {
- for (const auto & e : l->ends) {
+ for (const auto & link : links) {
+ for (const auto & end : link->ends) {
// cppcheck-suppress useStlAlgorithm
- if (e.node.get() == n.get()) {
- return e.dir;
+ if (end.node.get() == n.get()) {
+ return end.dir;
}
}
}
@@ -45,16 +45,17 @@ NetworkOf<T, Links...>::findNodeDirection(Node::AnyCPtr n) const
template<typename T, typename... Links>
Link::CCollection
-NetworkOf<T, Links...>::candidateStraight(GlobalPosition3D n1, GlobalPosition3D n2)
+NetworkOf<T, Links...>::candidateStraight(GlobalPosition3D positionA, GlobalPosition3D positionB)
{
- return {candidateLink<typename T::StraightLink>(n1, n2)};
+ return {candidateLink<typename T::StraightLink>(positionA, positionB)};
}
template<typename T, typename... Links>
Link::CCollection
NetworkOf<T, Links...>::candidateJoins(GlobalPosition3D start, GlobalPosition3D end)
{
- if (::distance(start, end) < 2000.F) {
+ static constexpr auto MIN_DISTANCE = 2000.F;
+ if (::distance(start, end) < MIN_DISTANCE) {
return {};
}
const auto defs = genCurveDef(
@@ -74,17 +75,17 @@ NetworkOf<T, Links...>::candidateExtend(GlobalPosition3D start, GlobalPosition3D
template<typename T, typename... Links>
Link::CCollection
-NetworkOf<T, Links...>::addStraight(const GeoData * geoData, GlobalPosition3D n1, GlobalPosition3D n2)
+NetworkOf<T, Links...>::addStraight(const GeoData * geoData, GlobalPosition3D positionA, GlobalPosition3D positionB)
{
Link::CCollection out;
- geoData->walk(n1.xy(), n2, [geoData, &out, this, &n1](const GeoData::WalkStep & step) {
+ geoData->walk(positionA.xy(), positionB, [geoData, &out, this, &positionA](const GeoData::WalkStep & step) {
if (step.previous.is_valid() && geoData->getSurface(step.current) != geoData->getSurface(step.previous)) {
const auto surfaceEdgePosition = geoData->positionAt(GeoData::PointFace(step.exitPosition, step.current));
- out.emplace_back(addLink<typename T::StraightLink>(n1, surfaceEdgePosition));
- n1 = surfaceEdgePosition;
+ out.emplace_back(addLink<typename T::StraightLink>(positionA, surfaceEdgePosition));
+ positionA = surfaceEdgePosition;
}
});
- out.emplace_back(addLink<typename T::StraightLink>(n1, n2));
+ out.emplace_back(addLink<typename T::StraightLink>(positionA, positionB));
return out;
}
@@ -92,6 +93,7 @@ template<typename T, typename... Links>
Link::CCollection
NetworkOf<T, Links...>::addCurve(const GeoData * geoData, const GenCurveDef & curve)
{
+ static constexpr auto MIN_DISTANCE = 2000.F;
auto [cstart, cend, centre] = curve;
Link::CCollection out;
std::set<GeoData::WalkStepCurve, SortedBy<&GeoData::WalkStepCurve::angle>> breaks;
@@ -115,7 +117,7 @@ NetworkOf<T, Links...>::addCurve(const GeoData * geoData, const GenCurveDef & cu
|| geoData->positionAt(GeoData::PointFace(step.exitPosition, step.current)).z;
});
points.push_back(cend);
- mergeClose(points, ::distance<3, GlobalDistance>, ::midpoint<3, GlobalDistance>, 2'000.F);
+ mergeClose(points, ::distance<3, GlobalDistance>, ::midpoint<3, GlobalDistance>, MIN_DISTANCE);
std::ranges::transform(points | std::views::pairwise, std::back_inserter(out), [this, centre](const auto pair) {
const auto [a, b] = pair;
return this->addLink<typename T::CurveLink>(a, b, centre);
@@ -127,7 +129,8 @@ template<typename T, typename... Links>
Link::CCollection
NetworkOf<T, Links...>::addJoins(const GeoData * geoData, GlobalPosition3D start, GlobalPosition3D end)
{
- if (::distance(start, end) < 2000.F) {
+ static constexpr auto MIN_DISTANCE = 2000.F;
+ if (::distance(start, end) < MIN_DISTANCE) {
return {};
}
const auto defs = genCurveDef(start, end, findNodeDirection(nodeAt(start)), findNodeDirection(nodeAt(end)));
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index dfe1dca..c0e597d 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -1,6 +1,5 @@
#include "rail.h"
#include "game/gamestate.h"
-#include "game/geoData.h"
#include "network.h"
#include <game/network/network.impl.h> // IWYU pragma: keep
#include <gfx/gl/sceneShader.h>
@@ -40,34 +39,33 @@ RailLinks::addLinksBetween(GlobalPosition3D start, GlobalPosition3D end)
const auto flatStart {start.xy()}, flatEnd {end.xy()};
if (node2ins.second == NodeIs::InNetwork) {
auto midheight = [&](auto mid) {
- const auto sm = ::distance<2>(flatStart, mid);
- const auto em = ::distance<2>(flatEnd, mid);
- return start.z + GlobalDistance(RelativeDistance(end.z - start.z) * (sm / (sm + em)));
+ const auto startToMid = ::distance<2>(flatStart, mid);
+ const auto endToMid = ::distance<2>(flatEnd, mid);
+ return start.z + GlobalDistance(RelativeDistance(end.z - start.z) * (startToMid / (startToMid + endToMid)));
};
const float dir2 = pi + findNodeDirection(node2ins.first);
- if (const auto radii = find_arcs_radius(flatStart, dir, flatEnd, dir2); radii.first < radii.second) {
- const auto radius {radii.first};
- const auto c1 = flatStart + (sincos(dir + half_pi) * radius);
- const auto c2 = flatEnd + (sincos(dir2 + half_pi) * radius);
- const auto mid = (c1 + c2) / 2;
+ const auto radii = find_arcs_radius(flatStart, dir, flatEnd, dir2);
+ if (radii.first < radii.second) {
+ const auto radius = radii.first;
+ const auto centre1 = flatStart + (sincos(dir + half_pi) * radius);
+ const auto centre2 = flatEnd + (sincos(dir2 + half_pi) * radius);
+ const auto mid = (centre1 + centre2) / 2;
const auto midh = mid || midheight(mid);
- addLink<RailLinkCurve>(start, midh, c1);
- return addLink<RailLinkCurve>(end, midh, c2);
- }
- else {
- const auto radius {radii.second};
- const auto c1 = flatStart + (sincos(dir - half_pi) * radius);
- const auto c2 = flatEnd + (sincos(dir2 - half_pi) * radius);
- const auto mid = (c1 + c2) / 2;
- const auto midh = mid || midheight(mid);
- addLink<RailLinkCurve>(midh, start, c1);
- return addLink<RailLinkCurve>(midh, end, c2);
+ addLink<RailLinkCurve>(start, midh, centre1);
+ return addLink<RailLinkCurve>(end, midh, centre2);
}
+ const auto radius = radii.second;
+ const auto centre1 = flatStart + (sincos(dir - half_pi) * radius);
+ const auto centre2 = flatEnd + (sincos(dir2 - half_pi) * radius);
+ const auto mid = (centre1 + centre2) / 2;
+ const auto midh = mid || midheight(mid);
+ addLink<RailLinkCurve>(midh, start, centre1);
+ return addLink<RailLinkCurve>(midh, end, centre2);
}
const auto diff = difference(end, start);
- const auto vy {vector_yaw(diff)};
- const auto n2ed {(vy * 2) - dir - pi};
- const auto centre {find_arc_centre(flatStart, dir, flatEnd, n2ed)};
+ const auto yaw = vector_yaw(diff);
+ const auto n2ed = (yaw * 2) - dir - pi;
+ const auto centre = find_arc_centre(flatStart, dir, flatEnd, n2ed);
if (centre.second) { // right hand arc
std::swap(start, end);
@@ -102,31 +100,34 @@ namespace {
}
}
-RailLinkStraight::RailLinkStraight(NetworkLinkHolder<RailLinkStraight> & instances, const Node::Ptr & a,
- const Node::Ptr & b) : RailLinkStraight(instances, a, b, b->pos - a->pos)
+RailLinkStraight::RailLinkStraight(NetworkLinkHolder<RailLinkStraight> & instances, const Node::Ptr & nodeA,
+ const Node::Ptr & nodeB) : RailLinkStraight(instances, nodeA, nodeB, nodeB->pos - nodeA->pos)
{
}
-RailLinkStraight::RailLinkStraight(
- NetworkLinkHolder<RailLinkStraight> & instances, Node::Ptr a, Node::Ptr b, const RelativePosition3D & diff) :
- Link({std::move(a), vector_yaw(diff)}, {std::move(b), vector_yaw(-diff)}, glm::length(diff)),
+RailLinkStraight::RailLinkStraight(NetworkLinkHolder<RailLinkStraight> & instances, Node::Ptr nodeA, Node::Ptr nodeB,
+ const RelativePosition3D & diff) :
+ Link({.node = std::move(nodeA), .dir = vector_yaw(diff)}, {.node = std::move(nodeB), .dir = vector_yaw(-diff)},
+ glm::length(diff)),
instance {instances.vertices.acquire(
ends[0].node->pos, ends[1].node->pos, flat_orientation(diff), roundSleepers(length))}
{
}
-RailLinkCurve::RailLinkCurve(
- NetworkLinkHolder<RailLinkCurve> & instances, const Node::Ptr & a, const Node::Ptr & b, GlobalPosition2D c) :
- RailLinkCurve(instances, a, b, c || a->pos.z, ::distance<2>(a->pos.xy(), c), {c, a->pos, b->pos})
+RailLinkCurve::RailLinkCurve(NetworkLinkHolder<RailLinkCurve> & instances, const Node::Ptr & nodeA,
+ const Node::Ptr & nodeB, GlobalPosition2D centre) :
+ RailLinkCurve(instances, nodeA, nodeB, centre || nodeA->pos.z, ::distance<2>(nodeA->pos.xy(), centre),
+ {centre, nodeA->pos, nodeB->pos})
{
}
-RailLinkCurve::RailLinkCurve(NetworkLinkHolder<RailLinkCurve> & instances, const Node::Ptr & a, const Node::Ptr & b,
- GlobalPosition3D c, RelativeDistance radius, const Arc arc) :
- Link({a, normalize(arc.first + half_pi)}, {b, normalize(arc.second - half_pi)},
- glm::length(RelativePosition2D {radius * arc.length(), difference(a->pos, b->pos).z})),
- LinkCurve {c, radius, arc}, instance {instances.vertices.acquire(ends[0].node->pos, ends[1].node->pos, c,
- roundSleepers(length), half_pi - arc.first, half_pi - arc.second, radius)}
+RailLinkCurve::RailLinkCurve(NetworkLinkHolder<RailLinkCurve> & instances, const Node::Ptr & nodeA,
+ const Node::Ptr & nodeB, GlobalPosition3D centre, RelativeDistance radius, const Arc arc) :
+ Link({.node = nodeA, .dir = normalize(arc.first + half_pi)},
+ {.node = nodeB, .dir = normalize(arc.second - half_pi)},
+ glm::length(RelativePosition2D {radius * arc.length(), difference(nodeA->pos, nodeB->pos).z})),
+ LinkCurve {centre, radius, arc}, instance {instances.vertices.acquire(ends[0].node->pos, ends[1].node->pos, centre,
+ roundSleepers(length), half_pi - arc.first, half_pi - arc.second, radius)}
{
}
@@ -155,11 +156,11 @@ template<> NetworkLinkHolder<RailLinkCurve>::NetworkLinkHolder()
namespace {
template<typename LinkType>
void
- renderType(const NetworkLinkHolder<LinkType> & n, auto & s)
+ renderType(const NetworkLinkHolder<LinkType> & networkLinks, auto & shader)
{
- if (auto count = n.vertices.size()) {
- s.use(RAIL_CROSS_SECTION, RAIL_TEXTURE_POS);
- glBindVertexArray(n.vao);
+ if (auto count = networkLinks.vertices.size()) {
+ shader.use(RAIL_CROSS_SECTION, RAIL_TEXTURE_POS);
+ glBindVertexArray(networkLinks.vao);
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(count));
}
};
@@ -188,5 +189,6 @@ RailLinks::getBaseSurface() const
RelativeDistance
RailLinks::getBaseWidth() const
{
- return 5'700;
+ static constexpr auto BASE_WIDTH = 5'700;
+ return BASE_WIDTH;
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-04-24 21:59:47 +0000