HexMetrics.h

浏览该文件的文档.

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
 
namespace eve::hexmap {
 
struct HexVec3 {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
};
 
[[nodiscard]] constexpr HexVec3 operator+(HexVec3 a, HexVec3 b) noexcept {
    return HexVec3{a.x + b.x, a.y + b.y, a.z + b.z};
}
[[nodiscard]] constexpr HexVec3 operator-(HexVec3 a, HexVec3 b) noexcept {
    return HexVec3{a.x - b.x, a.y - b.y, a.z - b.z};
}
[[nodiscard]] constexpr HexVec3  operator*(HexVec3 a, float s) noexcept { return HexVec3{a.x * s, a.y * s, a.z * s}; }
[[nodiscard]] constexpr HexVec3  operator*(float s, HexVec3 a) noexcept { return a * s; }
[[nodiscard]] constexpr HexVec3& operator+=(HexVec3& a, HexVec3 b) noexcept {
    a = a + b;
    return a;
}
 
struct HexVec4 {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
    float w = 0.f;
};
 
[[nodiscard]] constexpr HexVec3 lerp(HexVec3 a, HexVec3 b, float t) noexcept {
    return HexVec3{a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t};
}
 
[[nodiscard]] constexpr HexVec3 weightsLerp(HexVec3 a, HexVec3 b, float t) noexcept { return lerp(a, b, t); }
 
enum class HexDirection : std::int32_t { NE = 0, E = 1, SE = 2, SW = 3, W = 4, NW = 5 };
 
inline constexpr std::int32_t kHexDirectionCount = 6;
 
[[nodiscard]] constexpr HexDirection opposite(HexDirection d) noexcept {
    const auto v = static_cast<std::int32_t>(d);
    return static_cast<HexDirection>(v < 3 ? v + 3 : v - 3);
}
 
[[nodiscard]] constexpr HexDirection previous(HexDirection d) noexcept {
    return d == HexDirection::NE ? HexDirection::NW : static_cast<HexDirection>(static_cast<int>(d) - 1);
}
 
[[nodiscard]] constexpr HexDirection next(HexDirection d) noexcept {
    return d == HexDirection::NW ? HexDirection::NE : static_cast<HexDirection>(static_cast<int>(d) + 1);
}
 
[[nodiscard]] constexpr HexDirection previous2(HexDirection d) noexcept {
    const auto v = static_cast<std::int32_t>(d) - 2;
    return static_cast<HexDirection>(v < 0 ? v + 6 : v);
}
 
[[nodiscard]] constexpr HexDirection next2(HexDirection d) noexcept {
    const auto v = static_cast<std::int32_t>(d) + 2;
    return static_cast<HexDirection>(v > 5 ? v - 6 : v);
}
 
enum class HexEdgeType : std::int32_t { Flat = 0, Slope = 1, Cliff = 2 };
 
[[nodiscard]] constexpr HexEdgeType edgeType(int elevation1, int elevation2) noexcept {
    if (elevation1 == elevation2) return HexEdgeType::Flat;
    const int delta = elevation2 - elevation1;
    if (delta == 1 || delta == -1) return HexEdgeType::Slope;
    return HexEdgeType::Cliff;
}
 
class HexMetrics {
public:
    static constexpr float kOuterToInner = 0.866025404f;
    static constexpr float kInnerToOuter = 1.f / kOuterToInner;
    static constexpr float kDefaultOuterRadius = 10.f;
    static constexpr float kElevationStep = 3.f;
    static constexpr int kTerracesPerSlope = 2;
    static constexpr int kTerraceSteps = kTerracesPerSlope * 2 + 1;
    static constexpr float kHorizontalTerraceStepSize = 1.f / static_cast<float>(kTerraceSteps);
    static constexpr float kVerticalTerraceStepSize = 1.f / static_cast<float>(kTerracesPerSlope + 1);
    static constexpr float kSolidFactor = 0.8f;
    static constexpr float kBlendFactor = 1.f - kSolidFactor;
    static constexpr float kWaterFactor = 0.6f;
    static constexpr float kWaterBlendFactor = 1.f - kWaterFactor;
    static constexpr float kCellPerturbStrength = 4.f;
    static constexpr float kElevationPerturbStrength = 1.5f;
    static constexpr float kStreamBedElevationOffset = -1.75f;
    static constexpr float kWaterElevationOffset = -0.5f;
    static constexpr float kRiverSurfaceScale = 0.6f;
    static constexpr float kWallHeight = 4.f;
    static constexpr float kWallYOffset = -1.f;
    static constexpr float kWallThickness = 0.75f;
    static constexpr float kWallElevationOffset = kVerticalTerraceStepSize;
    static constexpr int kChunkSizeX = 5;
    static constexpr int kChunkSizeZ = 5;
    static constexpr int kMinElevation = -4;
    static constexpr int kMaxElevation = 8;
 
    static constexpr float kOuterRadius = kDefaultOuterRadius;
    static constexpr float kInnerRadius = kDefaultOuterRadius * kOuterToInner;
    static constexpr float kInnerDiameter = kInnerRadius * 2.f;
    static constexpr float kRowSpacing = kDefaultOuterRadius * 1.5f;
 
    [[nodiscard]] static constexpr float outerRadius() noexcept { return kOuterRadius; }
    [[nodiscard]] static constexpr float innerRadius() noexcept { return kInnerRadius; }
    [[nodiscard]] static constexpr float innerDiameter() noexcept { return kInnerDiameter; }
    [[nodiscard]] static constexpr float rowSpacing() noexcept { return kRowSpacing; }
 
    [[nodiscard]] static HexVec3 corner(HexDirection direction, float scale = 1.f) noexcept {
        const float r = kOuterRadius * scale;
        const float i = kInnerRadius * scale;
        switch (direction) {
            case HexDirection::NE: return HexVec3{0.f, 0.f, r};
            case HexDirection::E: return HexVec3{i, 0.f, 0.5f * r};
            case HexDirection::SE: return HexVec3{i, 0.f, -0.5f * r};
            case HexDirection::SW: return HexVec3{0.f, 0.f, -r};
            case HexDirection::W: return HexVec3{-i, 0.f, -0.5f * r};
            case HexDirection::NW: return HexVec3{-i, 0.f, 0.5f * r};
        }
        return HexVec3{0.f, 0.f, r};
    }
 
    [[nodiscard]] static HexVec3 firstCorner(HexDirection d) noexcept { return corner(d); }
    [[nodiscard]] static HexVec3 secondCorner(HexDirection d) noexcept { return corner(next(d)); }
    [[nodiscard]] static HexVec3 firstSolidCorner(HexDirection d) noexcept { return corner(d, kSolidFactor); }
    [[nodiscard]] static HexVec3 secondSolidCorner(HexDirection d) noexcept { return corner(next(d), kSolidFactor); }
    [[nodiscard]] static HexVec3 solidEdgeMiddle(HexDirection d) noexcept {
        return (corner(d) + corner(next(d))) * (0.5f * kSolidFactor);
    }
    [[nodiscard]] static HexVec3 firstWaterCorner(HexDirection d) noexcept { return corner(d, kWaterFactor); }
    [[nodiscard]] static HexVec3 secondWaterCorner(HexDirection d) noexcept { return corner(next(d), kWaterFactor); }
    [[nodiscard]] static HexVec3 bridge(HexDirection d) noexcept {
        return (corner(d) + corner(next(d))) * kBlendFactor;
    }
    [[nodiscard]] static HexVec3 waterBridge(HexDirection d) noexcept {
        return (corner(d) + corner(next(d))) * kWaterBlendFactor;
    }
 
    [[nodiscard]] static HexVec3 terraceLerp(HexVec3 a, HexVec3 b, int step) noexcept {
        const float h = static_cast<float>(step) * kHorizontalTerraceStepSize;
        a.x += (b.x - a.x) * h;
        a.z += (b.z - a.z) * h;
        const float v = static_cast<float>((step + 1) / 2) * kVerticalTerraceStepSize;
        a.y += (b.y - a.y) * v;
        return a;
    }
 
    [[nodiscard]] static HexVec3 terraceLerpWeights(HexVec3 a, HexVec3 b, int step) noexcept {
        const float h = static_cast<float>(step) * kHorizontalTerraceStepSize;
        return lerp(a, b, h);
    }
 
    [[nodiscard]] static HexVec3 wallLerp(HexVec3 near, HexVec3 far) noexcept {
        near.x += (far.x - near.x) * 0.5f;
        near.z += (far.z - near.z) * 0.5f;
        const float v = near.y < far.y ? kWallElevationOffset : (1.f - kWallElevationOffset);
        near.y += (far.y - near.y) * v + kWallYOffset;
        return near;
    }
 
    [[nodiscard]] static HexVec3 wallThicknessOffset(HexVec3 near, HexVec3 far) noexcept {
        float       dx  = far.x - near.x;
        float       dz  = far.z - near.z;
        const float len = std::sqrt(dx * dx + dz * dz);
        if (len <= 1e-6f) return HexVec3{0.f, 0.f, 0.f};
        const float s = (kWallThickness * 0.5f) / len;
        return HexVec3{dx * s, 0.f, dz * s};
    }
 
    [[nodiscard]] static float elevationY(int elevation) noexcept {
        return static_cast<float>(elevation) * kElevationStep;
    }
    [[nodiscard]] static float streamBedY(int elevation) noexcept {
        return static_cast<float>(elevation) * kElevationStep + kStreamBedElevationOffset;
    }
    [[nodiscard]] static float waterSurfaceY(int waterLevel) noexcept {
        return static_cast<float>(waterLevel) * kElevationStep + kWaterElevationOffset;
    }
 
    [[nodiscard]] static float solidRadius() noexcept { return innerRadius() * kSolidFactor; }
};
 
struct EdgeVertices {
    HexVec3 v1;
    HexVec3 v2;
    HexVec3 v3;
    HexVec3 v4;
    HexVec3 v5;
 
    EdgeVertices() = default;
 
    EdgeVertices(HexVec3 c1, HexVec3 c2) noexcept {
        v1 = c1;
        v2 = lerp(c1, c2, 0.25f);
        v3 = lerp(c1, c2, 0.5f);
        v4 = lerp(c1, c2, 0.75f);
        v5 = c2;
    }
 
    EdgeVertices(HexVec3 c1, HexVec3 c2, float outerStep) noexcept {
        v1 = c1;
        v2 = lerp(c1, c2, outerStep);
        v3 = lerp(c1, c2, 0.5f);
        v4 = lerp(c1, c2, 1.f - outerStep);
        v5 = c2;
    }
 
    [[nodiscard]] static EdgeVertices terraceLerp(const EdgeVertices& a, const EdgeVertices& b, int step) noexcept {
        EdgeVertices result;
        result.v1 = HexMetrics::terraceLerp(a.v1, b.v1, step);
        result.v2 = HexMetrics::terraceLerp(a.v2, b.v2, step);
        result.v3 = HexMetrics::terraceLerp(a.v3, b.v3, step);
        result.v4 = HexMetrics::terraceLerp(a.v4, b.v4, step);
        result.v5 = HexMetrics::terraceLerp(a.v5, b.v5, step);
        return result;
    }
};
 
}  // namespace eve::hexmap