GtsTerrainLod.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "procgen/GtsMeshSimplifier.h"
#include "procgen/GtsMeshSplitter.h"
 
#include <vector>
#include <string>
 
namespace eve::procgen {
 
class GtsTerrainLodSet;
class Heightmap;
 
enum class GtsTerrainSaveResolution : int { Full=0,Half=1,Quarter=2,Eighth=3,Sixteenth=4 };
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> buildGtsTerrainBaseMesh(MeshBuild& output, const Heightmap& heightmap,
                                                                        GtsTerrainSaveResolution resolution,
                                                                        float sizeX, float sizeY, float sizeZ);
 
struct GtsTerrainLodLevelSettings {
    float quality = 1.0f;
    float screenRelativeTransitionHeight = 0.95f;
    GtsMeshSimplificationOptions simplification{};
};
 
class EVENGINE_API_DOMAINS GtsTerrainMeshSettings {
public:
    [[nodiscard]] int getSaveResolution() const noexcept { return saveResolution_; }
    [[nodiscard]] Result<void> setSaveResolution(int value);
    [[nodiscard]] int getLodCount() const noexcept { return lodCount_; }
    [[nodiscard]] Result<void> setLodCount(int value);
    [[nodiscard]] int getSubTiles() const noexcept { return subTiles_; }
    [[nodiscard]] Result<void> setSubTiles(int value);
    [[nodiscard]] float getLodQuality(int index) const noexcept;
    [[nodiscard]] Result<void> setLodQuality(int index,float percent);
    [[nodiscard]] float getLodTransitionHeight(int index) const noexcept;
    [[nodiscard]] Result<std::string> snapshotJson() const;
    [[nodiscard]] Result<void> restoreJson(const std::string& json);
    [[nodiscard]] Result<std::vector<GtsTerrainLodLevelSettings>> compileLevels() const;
private:
    int saveResolution_=0,lodCount_=4,subTiles_=3;
    float lodQuality_[4]{100.f,50.f,25.f,12.5f};
};
 
struct GtsTerrainLodTile {
    float offsetX = 0.0f;
    float offsetZ = 0.0f;
    std::vector<MeshBuild> levels;
};
 
struct GtsTerrainLodAssetEntry {
    int tileIndex=0;
    int levelIndex=0;
    std::string objectName;
    std::string meshName;
    std::string relativePath;
};
 
class EVENGINE_API_DOMAINS GtsTerrainLodAssetPlan {
public:
    [[nodiscard]] int getEntryCount() const;
    [[nodiscard]] int getTileIndex(int index)const;
    [[nodiscard]] int getLevelIndex(int index)const;
    [[nodiscard]] std::string getObjectName(int index)const;
    [[nodiscard]] std::string getMeshName(int index)const;
    [[nodiscard]] std::string getRelativePath(int index)const;
private:
    friend EVENGINE_API_DOMAINS Result<void> planGtsTerrainLodAssetsInto(GtsTerrainLodAssetPlan&,
                                                                         const GtsTerrainLodSet&, const std::string&,
                                                                         const std::string&);
    std::vector<GtsTerrainLodAssetEntry>entries_;
};
 
class EVENGINE_API_DOMAINS GtsTerrainLodSet {
public:
    [[nodiscard]] int getColumnCount() const { return columns_; }
    [[nodiscard]] int getRowCount() const { return rows_; }
    [[nodiscard]] int getTileCount() const { return static_cast<int>(tiles_.size()); }
    [[nodiscard]] int getLevelCount() const { return static_cast<int>(settings_.size()); }
    [[nodiscard]] const GtsTerrainLodTile* tileAt(int index) const;
    [[nodiscard]] const GtsTerrainLodLevelSettings* levelAt(int index) const;
    [[nodiscard]] int selectLevel(float relativeHeight) const;
    [[nodiscard]] float getLevelSwitchDistance(int level, float worldDiameter, float verticalFovDegrees) const;
    [[nodiscard]] int selectLevelForCamera(float distance, float worldDiameter, float verticalFovDegrees) const;
    [[nodiscard]] Result<std::string> snapshotJson() const;
    [[nodiscard]] Result<void> restoreJson(const std::string& json);
 
private:
    friend EVENGINE_API_DOMAINS Result<GtsTerrainLodSet> buildGtsTerrainLods(
        const MeshBuild&, int, int, GtsMeshPivot, const std::vector<GtsTerrainLodLevelSettings>&);
    int columns_ = 0;
    int rows_ = 0;
    std::vector<GtsTerrainLodLevelSettings> settings_;
    std::vector<GtsTerrainLodTile> tiles_;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<GtsTerrainLodSet> buildGtsTerrainLods(
    const MeshBuild& source, int xSplits, int zSplits, GtsMeshPivot pivot,
    const std::vector<GtsTerrainLodLevelSettings>& levels);
 
[[nodiscard]] Result<GtsTerrainLodSet> buildGtsTerrainLodsFromHeightmap(const Heightmap& heightmap,
    GtsTerrainSaveResolution resolution,float sizeX,float sizeY,float sizeZ,int subTileSplits,
    GtsMeshPivot pivot,const std::vector<GtsTerrainLodLevelSettings>& levels);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> buildDefaultGtsTerrainLodsFromHeightmapInto(
    GtsTerrainLodSet& output, const Heightmap& heightmap, GtsTerrainSaveResolution resolution, float sizeX, float sizeY,
    float sizeZ, int subTileSplits, GtsMeshPivot pivot = GtsMeshPivot::None);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> buildGtsTerrainLodsFromHeightmapInto(
    GtsTerrainLodSet& output, const Heightmap& heightmap, const GtsTerrainMeshSettings& settings, float sizeX,
    float sizeY, float sizeZ, GtsMeshPivot pivot = GtsMeshPivot::None);
 
[[nodiscard]] EVENGINE_API_DOMAINS std::vector<GtsTerrainLodLevelSettings> defaultGtsTerrainLodLevels();
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::vector<GtsTerrainLodAssetEntry>> planGtsTerrainLodAssets(
    const GtsTerrainLodSet& lods, const std::string& terrainName, const std::string& meshFolder = "Meshes");
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> planGtsTerrainLodAssetsInto(GtsTerrainLodAssetPlan& output,
                                                                            const GtsTerrainLodSet& lods,
                                                                            const std::string&      terrainName,
                                                                            const std::string& meshFolder = "Meshes");
}