GtsTerrainExportSettings.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "procgen/GtsTerrainLod.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::image { class ImageData; }
 
namespace eve::procgen {
class Heightmap;
 
enum class GtsTerrainLodMode : int { Impostor = 0, LowPoly = 1, Custom = 2 };
enum class GtsTerrainNormalEdgeMode : int { Smooth = 0, Sharp = 1 };
enum class GtsTerrainTextureExportMethod : int { OrthographicBake = 0, BaseMapExport = 1 };
enum class GtsTerrainBakeLighting : int { NeutralLighting = 0, CurrentSceneLighting = 1 };
enum class GtsTerrainAlphaChannel : int { None = 0, Heightmap = 1 };
enum class GtsTerrainExportShader : int { Standard = 0, VertexColor = 1 };
enum class GtsTerrainConversionAction : int { MeshTerrain = 0, ColliderOnly = 1, ObjFileExport = 2 };
enum class GtsSourceTerrainTreatment : int { Nothing = 0, Deactivate = 1, StoreInBackup = 2, Delete = 3 };
enum class GtsTerrainExportSelection : int { AllTerrains = 0, SingleTerrain = 1 };
enum class GtsTerrainColliderType : int { Mesh = 0, Heightfield = 1 };
enum class GtsTerrainObjFaceMode : int { Triangles = 0, Quads = 1 };
 
struct GtsTerrainExportWorkflow {
    GtsTerrainConversionAction action = GtsTerrainConversionAction::MeshTerrain;
    GtsSourceTerrainTreatment sourceTreatment = GtsSourceTerrainTreatment::Deactivate;
    GtsTerrainExportSelection selection = GtsTerrainExportSelection::AllTerrains;
    GtsTerrainObjFaceMode objFaceMode = GtsTerrainObjFaceMode::Triangles;
    bool addTerrainCollider = true;
    GtsTerrainColliderType colliderType = GtsTerrainColliderType::Heightfield;
    bool addMeshColliderToImpostor = true;
    bool invertExportMask = false;
    bool copyPcgObjects = true;
    bool convertTreesToObjects = true;
    bool copyPcgObjectsToImpostor = false;
    bool convertSourceTerrains = false;
    GtsTerrainSaveResolution colliderResolution = GtsTerrainSaveResolution::Full;
    float colliderSimplifyQuality = 1.0f;
    bool addTreeColliders = true;
    bool addObjectColliders = true;
    bool createColliderScenes = true;
    bool bakeCombinedCollisionMesh = true;
    bool createImpostorScenes = false;
    double impostorRange = 0.0;
};
 
struct GtsTerrainExportLodSettings {
    GtsTerrainSaveResolution saveResolution = GtsTerrainSaveResolution::Half;
    float simplifyQuality = 1.0f;
    GtsMeshSimplificationOptions simplification{};
    GtsTerrainNormalEdgeMode normalEdgeMode = GtsTerrainNormalEdgeMode::Smooth;
    GtsTerrainLodMode mode = GtsTerrainLodMode::Impostor;
    bool exportTextures = true;
    bool exportNormalMaps = true;
    bool exportSplatmaps = true;
    bool createMaterials = true;
    GtsTerrainExportShader materialShader = GtsTerrainExportShader::Standard;
    bool bakeVertexColors = true;
    int vertexColorSmoothing = 3;
    std::uint32_t bakeLayerMask = 0xffffffffU;
    GtsTerrainTextureExportMethod textureExportMethod = GtsTerrainTextureExportMethod::OrthographicBake;
    GtsTerrainAlphaChannel alphaChannel = GtsTerrainAlphaChannel::Heightmap;
    int textureExportResolution = 2048;
    GtsTerrainBakeLighting bakeLighting = GtsTerrainBakeLighting::NeutralLighting;
    std::string namePrefix;
    bool captureBaseMapTextures = false;
    float screenRelativeTransitionHeight = 0.8f;
 
    [[nodiscard]] Result<void> validate() const;
    [[nodiscard]] Result<GtsTerrainLodLevelSettings> compileLevel() const;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<GtsTerrainExportLodSettings> makeGtsTerrainImpostorLod(int level);
[[nodiscard]] EVENGINE_API_DOMAINS Result<GtsTerrainExportLodSettings> makeGtsTerrainLowPolyLod(int level);
 
class EVENGINE_API_DOMAINS GtsTerrainExportSettings {
public:
    [[nodiscard]] Result<void> configureWorkflow(const GtsTerrainExportWorkflow& workflow);
    [[nodiscard]] GtsTerrainExportWorkflow getWorkflow() const noexcept;
    [[nodiscard]] Result<void> appendSourcePreset(int mode, int level, float quality, float transitionHeight);
    [[nodiscard]] Result<void> appendImpostorPreset(int mode, int level, float quality, float transitionHeight);
    [[nodiscard]] Result<void> setSourceLods(std::vector<GtsTerrainExportLodSettings> levels);
    [[nodiscard]] Result<void> setImpostorLods(std::vector<GtsTerrainExportLodSettings> levels);
    [[nodiscard]] int getSourceLodCount() const noexcept;
    [[nodiscard]] int getImpostorLodCount() const noexcept;
    [[nodiscard]] const GtsTerrainExportLodSettings* sourceLodAt(int index) const noexcept;
    [[nodiscard]] const GtsTerrainExportLodSettings* impostorLodAt(int index) const noexcept;
    [[nodiscard]] Result<std::vector<GtsTerrainLodLevelSettings>> compileSourceLevels() const;
    [[nodiscard]] Result<std::string> snapshotJson() const;
    [[nodiscard]] Result<void> restoreJson(const std::string& json);
 
private:
    GtsTerrainExportWorkflow workflow_{};
    std::vector<GtsTerrainExportLodSettings> sourceLods_;
    std::vector<GtsTerrainExportLodSettings> impostorLods_;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> buildGtsTerrainExportLodsFromHeightmapInto(
    GtsTerrainLodSet& output, const Heightmap& heightmap, const GtsTerrainExportSettings& settings, float sizeX,
    float sizeY, float sizeZ, int subTiles, GtsMeshPivot pivot = GtsMeshPivot::None);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<void> buildGtsTerrainColliderMeshFromHeightmapInto(
    MeshBuild& output, const Heightmap& heightmap, const GtsTerrainExportWorkflow& workflow, float sizeX, float sizeY,
    float sizeZ);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::string> encodeGtsTerrainObj(const Heightmap&         heightmap,
                                                                           GtsTerrainSaveResolution resolution,
                                                                           float sizeX, float sizeY, float sizeZ,
                                                                           GtsTerrainObjFaceMode faceMode);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<std::string> encodeGtsMaskedTerrainObj(
    const Heightmap& heightmap, const Heightmap& maskmap, GtsTerrainSaveResolution resolution, float sizeX, float sizeY,
    float sizeZ, GtsTerrainObjFaceMode faceMode, float threshold = 0.2f, bool invert = false);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> bakeGtsTerrainVertexColorsInto(
    MeshBuild& output, const MeshBuild& source, const image::ImageData& bakedTexture, GtsTerrainNormalEdgeMode edgeMode,
    int smoothingIterations, float terrainSizeX, float terrainSizeZ, bool linearize = false);
 
}  // namespace eve::procgen