HexSphereMap.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "hexmap/HexCell.h"
#include "hexmap/HexMetrics.h"
#include "hexmap/HexNoise.h"
#include "hexmap/HexSphereTopology.h"
 
#include <cstdint>
#include <vector>
 
namespace eve::hexmap {
 
class EVENGINE_API_WORLD HexSphereMap {
public:
    static constexpr float kDefaultElevationRatio = 0.006f;
 
    HexSphereMap() = default;
 
    [[nodiscard]] Result<void> reset(std::int32_t subdivision, float radius, std::uint32_t seed);
 
    // --- shape and identity -------------------------------------------------
 
    [[nodiscard]] bool empty() const noexcept { return cells_.empty(); }
    [[nodiscard]] std::int32_t subdivision() const noexcept { return topology_.subdivision(); }
    [[nodiscard]] std::int32_t frequency() const noexcept { return topology_.frequency(); }
    [[nodiscard]] std::int32_t cellCount() const noexcept { return static_cast<std::int32_t>(cells_.size()); }
    [[nodiscard]] std::int32_t pentagonCount() const noexcept { return topology_.pentagonCount(); }
    [[nodiscard]] float sphereRadius() const noexcept { return sphereRadius_; }
    [[nodiscard]] float cellSpacing() const noexcept;
    [[nodiscard]] float elevationStep() const noexcept { return elevationStep_; }
    void setElevationStep(float step) noexcept;
    [[nodiscard]] std::uint32_t seed() const noexcept { return noise_.seed(); }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
    [[nodiscard]] const HexNoise& noise() const noexcept { return noise_; }
    [[nodiscard]] const HexSphereTopology& topology() const noexcept { return topology_; }
 
    // --- topology -----------------------------------------------------------
 
    [[nodiscard]] bool contains(HexSphereCell cell) const noexcept { return topology_.contains(cell); }
    [[nodiscard]] bool isPentagon(HexSphereCell cell) const noexcept { return topology_.isPentagon(cell); }
    [[nodiscard]] std::int32_t neighborCount(HexSphereCell cell) const noexcept {
        return topology_.neighborCount(cell);
    }
    [[nodiscard]] HexSphereCell neighbor(HexSphereCell cell, std::int32_t direction) const noexcept {
        return topology_.neighbor(cell, direction);
    }
    [[nodiscard]] std::int32_t directionOf(HexSphereCell cell, HexSphereCell other) const noexcept {
        return topology_.directionOf(cell, other);
    }
    [[nodiscard]] std::int32_t oppositeDirection(HexSphereCell cell, std::int32_t direction) const noexcept {
        return topology_.oppositeDirection(cell, direction);
    }
    [[nodiscard]] std::int32_t cornerCountOf(HexSphereCell cell) const noexcept {
        return topology_.cornerCountOf(cell);
    }
    [[nodiscard]] HexEdgeType edgeTypeTo(HexSphereCell a, HexSphereCell b) const noexcept;
 
    // --- geometry -----------------------------------------------------------
 
    [[nodiscard]] HexVec3 direction(HexSphereCell cell) const noexcept { return topology_.direction(cell); }
    [[nodiscard]] HexVec3 cornerDirection(HexSphereCell cell, std::int32_t corner) const noexcept {
        return topology_.corner(cell, corner);
    }
    [[nodiscard]] float surfaceRadius(HexSphereCell cell) const noexcept;
    [[nodiscard]] HexVec3 cellPosition(HexSphereCell cell) const noexcept;
    [[nodiscard]] HexVec3 cellGroundPosition(HexSphereCell cell) const noexcept;
 
    // --- cell access --------------------------------------------------------
 
    [[nodiscard]] const HexCellData* cellAt(HexSphereCell cell) const noexcept;
 
    [[nodiscard]] std::int32_t elevation(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t waterLevel(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t terrainType(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t urbanLevel(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t farmLevel(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t plantLevel(HexSphereCell c) const noexcept;
    [[nodiscard]] std::int32_t specialIndex(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         isUnderwater(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         hasRiver(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         hasRoad(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         hasRiverThrough(HexSphereCell c, std::int32_t direction) const noexcept;
    [[nodiscard]] bool         isWalled(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         isExplored(HexSphereCell c) const noexcept;
    [[nodiscard]] bool         isExplorable(HexSphereCell c) const noexcept;
    [[nodiscard]] HexValues    values(HexSphereCell c) const noexcept;
    [[nodiscard]] HexFlags     flags(HexSphereCell c) const noexcept;
 
    // --- picking ------------------------------------------------------------
 
    [[nodiscard]] Result<HexSphereCell> pickCell(HexVec3 rayOrigin, HexVec3 rayDirection) const;
 
    // --- neighbourhood queries ----------------------------------------------
 
    [[nodiscard]] std::int32_t distance(HexSphereCell a, HexSphereCell b) const;
 
    void collectBrush(HexSphereCell center, std::int32_t radius, std::vector<HexSphereCell>& out) const;
 
    [[nodiscard]] Result<void> editElevation(HexSphereCell center, std::int32_t radius, std::int32_t delta);
    [[nodiscard]] Result<void> editWaterLevel(HexSphereCell center, std::int32_t radius, std::int32_t delta);
    [[nodiscard]] Result<void> editTerrainType(HexSphereCell center, std::int32_t radius, std::int32_t terrainType);
    [[nodiscard]] Result<void> editFeatureLevel(HexSphereCell center, std::int32_t radius, std::int32_t feature,
                                                std::int32_t delta);
 
    // --- cell authoring -----------------------------------------------------
 
    [[nodiscard]] Result<void> setElevation(HexSphereCell c, std::int32_t elevation);
    [[nodiscard]] Result<void> setWaterLevel(HexSphereCell c, std::int32_t waterLevel);
    [[nodiscard]] Result<void> setTerrainType(HexSphereCell c, std::int32_t terrainType);
    [[nodiscard]] Result<void> setUrbanLevel(HexSphereCell c, std::int32_t level);
    [[nodiscard]] Result<void> setFarmLevel(HexSphereCell c, std::int32_t level);
    [[nodiscard]] Result<void> setPlantLevel(HexSphereCell c, std::int32_t level);
    [[nodiscard]] Result<void> setSpecialIndex(HexSphereCell c, std::int32_t index);
    [[nodiscard]] Result<void> setWalled(HexSphereCell c, bool walled);
    [[nodiscard]] Result<void> setExplored(HexSphereCell c, bool explored);
    [[nodiscard]] Result<void> setExplorable(HexSphereCell c, bool explorable);
    [[nodiscard]] Result<void> setCellState(HexSphereCell c, HexValues values, HexFlags flags);
    [[nodiscard]] Result<void> setOutgoingRiver(HexSphereCell c, std::int32_t direction);
    [[nodiscard]] Result<void> removeRiver(HexSphereCell c);
    [[nodiscard]] Result<void> addRoad(HexSphereCell c, std::int32_t direction);
    [[nodiscard]] Result<void> removeRoads(HexSphereCell c);
 
    // --- dirty tracking -----------------------------------------------------
 
    void markAllDirty() noexcept;
    void markCellDirtyAndNeighbors(HexSphereCell cell) noexcept;
    [[nodiscard]] std::int32_t takeDirtyCell() noexcept;
    [[nodiscard]] std::int32_t dirtyCellCount() const noexcept {
        return static_cast<std::int32_t>(dirtyQueue_.size() - dirtyHead_);
    }
 
private:
    void         markCellDirty(HexSphereCell cell) noexcept;
    void         refreshCellDependents(HexSphereCell cell) noexcept;
    void         validateRivers(HexSphereCell cell) noexcept;
    HexCellData* mutableCell(HexSphereCell cell) noexcept;
 
    HexSphereTopology         topology_{};
    HexNoise                  noise_{};
    std::vector<HexCellData>  cells_;
    std::vector<std::uint8_t> cellDirty_;
    std::vector<std::int32_t> dirtyQueue_;
    std::size_t               dirtyHead_    = 0;
    std::uint64_t             revision_     = 0;
    float                     sphereRadius_ = 0.f;
    float                     elevationStep_ = 0.f;
};
 
}  // namespace eve::hexmap