HexMapModule.h

浏览该文件的文档.

#pragma once
 
#include "common/Module.h"
#include "common/Result.h"
#include "hexmap/HexMap.h"
#include "hexmap/HexMapMesh.h"
#include "hexmap/HexSearch.h"
#include "hexmap/HexSerializer.h"
#include "hexmap/HexSphereMap.h"
#include "hexmap/HexTerrainBake.h"
#include "hexmap/HexUnits.h"
#include "hexmap/HexVisibility.h"
 
#include <cstdint>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Mesh;
}  // namespace eve::graphics
 
namespace eve::hexmap {
 
class EVENGINE_API_WORLD HexMapModule : public Module {
public:
    Module_REG(HexMapModule);
 
    HexMapModule();
    ~HexMapModule() override;
 
    [[nodiscard]] Result<void> newGrid(graphics::Graphics* gfx, std::int32_t cellCountX, std::int32_t cellCountZ,
                                       std::uint32_t seed);
 
    std::int32_t rebuildDirtyChunks(graphics::Graphics* gfx);
 
    std::int32_t rebuildChunk(graphics::Graphics* gfx, std::int32_t chunkIndex);
 
    [[nodiscard]] graphics::Mesh* chunkMeshAt(std::int32_t chunkIndex, HexSurface surface) const;
 
    void releaseMeshes(graphics::Graphics* gfx);
 
    [[nodiscard]] const HexMap& map() const noexcept { return map_; }
    [[nodiscard]] HexMap& map() noexcept { return map_; }
    [[nodiscard]] bool hasGrid() const noexcept { return !map_.empty(); }
 
    // --- spherical map ------------------------------------------------------
 
    [[nodiscard]] Result<void> newSphere(graphics::Graphics* gfx, std::int32_t subdivision, float radius,
                                         std::uint32_t seed);
 
    [[nodiscard]] Result<void> rebuildSphere(graphics::Graphics* gfx);
 
    void releaseSphereMeshes(graphics::Graphics* gfx) noexcept;
 
    [[nodiscard]] const HexSphereMap& sphere() const noexcept { return sphere_; }
    [[nodiscard]] HexSphereMap& sphere() noexcept { return sphere_; }
    [[nodiscard]] graphics::Mesh* sphereTerrainMesh() const noexcept { return sphereTerrain_; }
    [[nodiscard]] graphics::Mesh* sphereWaterMesh() const noexcept { return sphereWater_; }
 
    [[nodiscard]] HexVisibility& visibility() noexcept { return visibility_; }
    [[nodiscard]] HexUnitRegistry& units() noexcept { return units_; }
    [[nodiscard]] HexSearchContext& scratch() noexcept { return scratch_; }
 
    [[nodiscard]] Result<void> adoptGrid(graphics::Graphics* gfx, HexMap&& restored,
                                         const std::vector<HexUnitState>& units);
 
    void syncScratch();
 
    [[nodiscard]] Result<void> applyTerrain(graphics::Graphics* gfx, const HexTerrainBake& bake);
 
    [[nodiscard]] Result<void> applySphereTerrain(graphics::Graphics* gfx, const HexTerrainBake& bake);
 
private:
    [[nodiscard]] std::int32_t meshSlot(std::int32_t chunkIndex, HexSurface surface) const noexcept;
    void                       clearMeshSlots() noexcept;
 
    HexMap                       map_{};
    std::vector<graphics::Mesh*> meshes_{};
    std::vector<std::uint8_t>    meshPopulated_{};
    HexSearchContext             scratch_{};
    HexVisibility                visibility_{};
    HexUnitRegistry              units_{};
 
    HexSphereMap    sphere_{};
    graphics::Mesh* sphereTerrain_ = nullptr;
    graphics::Mesh* sphereWater_   = nullptr;
};
 
}  // namespace eve::hexmap