TerrainAsset.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "procgen/heightmap/TerrainPipeline.h"
#include "common/Result.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
namespace eve::procgen {
 
class ITerrainArchiveSource {
public:
    virtual ~ITerrainArchiveSource() = default;
    [[nodiscard]] virtual std::uint64_t size() const noexcept = 0;
    [[nodiscard]] virtual Result<std::vector<std::uint8_t>> read(
        std::uint64_t offset, std::size_t length) const = 0;
};
 
class MemoryTerrainArchiveSource final : public ITerrainArchiveSource {
public:
    explicit MemoryTerrainArchiveSource(std::span<const std::uint8_t> bytes)
        : bytes_(bytes.begin(), bytes.end()) {}
    [[nodiscard]] std::uint64_t size() const noexcept override { return bytes_.size(); }
    [[nodiscard]] Result<std::vector<std::uint8_t>> read(
        std::uint64_t offset, std::size_t length) const override;
 
private:
    std::vector<std::uint8_t> bytes_;
};
 
struct TerrainChunkData {
    int chunkX = 0, chunkY = 0;
    int width = 0, height = 0;
    Heightmap heights;
    std::vector<float> flowAccumulation, flowVectorX, flowVectorY;
    std::vector<float> lakeDepth, temperature, moisture;
    std::vector<int8_t> flowDirection;
    std::vector<uint8_t> rivers, streamOrder;
    std::vector<Biome> biomes;
};
 
struct TerrainChunkEntry {
    int chunkX = 0, chunkY = 0;
    int width = 0, height = 0;
    uint64_t offset = 0;
    uint32_t storedSize = 0, rawSize = 0, checksum = 0;
    bool compressed = false;
};
 
class EVENGINE_API_DOMAINS TerrainAsset {
public:
    static bool bake(const Heightmap &heightmap, const HydrologyMap &hydrology,
                     const ClimateMap &climate, int chunkSize, std::vector<uint8_t> &out,
                     std::string *error = nullptr);
 
    bool open(const uint8_t *data, size_t size, std::string *error = nullptr);
    [[nodiscard]] Result<void> openSource(std::shared_ptr<const ITerrainArchiveSource> source);
    bool loadChunk(int chunkX, int chunkY, TerrainChunkData &out,
                   std::string *error = nullptr) const;
 
    int getWidth() const { return width_; }
    int getHeight() const { return height_; }
    int getChunkSize() const { return chunkSize_; }
    float getMinHeight() const { return minHeight_; }
    float getMaxHeight() const { return maxHeight_; }
    const std::vector<TerrainChunkEntry> &chunks() const { return chunks_; }
    [[nodiscard]] const TerrainChunkEntry* findChunk(int chunkX, int chunkY) const noexcept;
 
private:
    bool openMetadata(const std::uint8_t* data, std::size_t metadataSize,
                      std::uint64_t archiveSize, std::string* error);
    int width_ = 0, height_ = 0, chunkSize_ = 0;
    uint16_t version_ = 0;
    float minHeight_ = 0.f, maxHeight_ = 1.f, maxFlow_ = 1.f;
    std::shared_ptr<const ITerrainArchiveSource> source_;
    std::vector<TerrainChunkEntry> chunks_;
};
 
}  // namespace eve::procgen