TerrainSplatmap.h

浏览该文件的文档.

#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "common/Result.h"
 
namespace eve::procgen {
class Heightmap;
struct TerrainMultiTileReport;
struct TerrainStampSettings;
class GtsHeightBlendSet;
struct TerrainTextureAlignSettings;
 
class EVENGINE_API_DOMAINS TerrainSplatmap {
public:
    TerrainSplatmap();
    ~TerrainSplatmap();
    TerrainSplatmap(TerrainSplatmap&&) noexcept;
    TerrainSplatmap& operator=(TerrainSplatmap&&) noexcept;
    TerrainSplatmap(const TerrainSplatmap&);
    TerrainSplatmap& operator=(const TerrainSplatmap&);
    [[nodiscard]] Result<int> initialize(int width, int height, int layerCount, int defaultLayer = 0);
    [[nodiscard]] Result<float> sample(int layer, int x, int y) const;
    [[nodiscard]] Result<int> copyLayer(int layer, Heightmap& output) const;
    int getLastChangedSamples() const noexcept;
    int getWidth() const noexcept;
    int getHeight() const noexcept;
    int getLayerCount() const noexcept;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    friend EVENGINE_API_DOMAINS Result<int> paintTerrainSplatLayer(TerrainSplatmap&, const Heightmap&, int);
    friend EVENGINE_API_DOMAINS Result<int> applyGtsHeightBlend(TerrainSplatmap&, const TerrainSplatmap&,
                                                                const GtsHeightBlendSet&, float);
    friend EVENGINE_API_DOMAINS Result<int> alignTerrainSplatTextures(TerrainSplatmap&, TerrainSplatmap&,
                                                                      const TerrainTextureAlignSettings&);
    friend EVENGINE_API_DOMAINS Result<TerrainMultiTileReport> paintTerrainSplatLayerMultiTile(
        const std::vector<struct TerrainSplatTile>&, const Heightmap&, int, const TerrainStampSettings&, bool,
        const std::vector<std::string>&);
};
 
struct TerrainTextureAlignSettings {
    float terrainAOriginX = 0;
    float terrainAOriginZ = 0;
    float terrainAWidth = 1;
    float terrainADepth = 1;
    float terrainBOriginX = 1;
    float terrainBOriginZ = 0;
    float terrainBWidth = 1;
    float terrainBDepth = 1;
    float blendStrength = 1;
    int blendWidth = 8;
    float adjacencyTolerance = 1.5F;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> alignTerrainSplatTextures(TerrainSplatmap&                   terrainA,
                                                                         TerrainSplatmap&                   terrainB,
                                                                         const TerrainTextureAlignSettings& settings);
 
class EVENGINE_API_DOMAINS GtsHeightBlendSet {
public:
    GtsHeightBlendSet();
    ~GtsHeightBlendSet();
    GtsHeightBlendSet(GtsHeightBlendSet&&) noexcept;
    GtsHeightBlendSet& operator=(GtsHeightBlendSet&&) noexcept;
    GtsHeightBlendSet(const GtsHeightBlendSet&) = delete;
    GtsHeightBlendSet& operator=(const GtsHeightBlendSet&) = delete;
    [[nodiscard]] Result<int> addLayer(const Heightmap& height, float contrast = 1,
                                       float brightness = 1, float increase = 0);
    int getLayerCount() const noexcept;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    friend EVENGINE_API_DOMAINS Result<int> applyGtsHeightBlend(TerrainSplatmap&, const TerrainSplatmap&,
                                                                const GtsHeightBlendSet&, float);
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> applyGtsHeightBlend(TerrainSplatmap&         output,
                                                                   const TerrainSplatmap&   input,
                                                                   const GtsHeightBlendSet& heights, float blendFactor);
 
struct TerrainSplatTile {
    std::string name;
    TerrainSplatmap* splatmap = nullptr;
    double originX = 0, originZ = 0, width = 1, depth = 1;
    bool worldMap = false;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> paintTerrainSplatLayer(TerrainSplatmap& target, const Heightmap& paint,
                                                                      int targetLayer);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<TerrainMultiTileReport> paintTerrainSplatLayerMultiTile(
    const std::vector<TerrainSplatTile>& tiles, const Heightmap& operationPaint, int targetLayer,
    const TerrainStampSettings& operationSettings, bool worldMapOperation = false,
    const std::vector<std::string>& validTerrainNames = {});
 
class EVENGINE_API_DOMAINS TerrainMultiSplatWorkspace {
public:
    TerrainMultiSplatWorkspace();
    ~TerrainMultiSplatWorkspace();
    TerrainMultiSplatWorkspace(TerrainMultiSplatWorkspace&&) noexcept;
    TerrainMultiSplatWorkspace& operator=(TerrainMultiSplatWorkspace&&) noexcept;
    TerrainMultiSplatWorkspace(const TerrainMultiSplatWorkspace&) = delete;
    TerrainMultiSplatWorkspace& operator=(const TerrainMultiSplatWorkspace&) = delete;
    [[nodiscard]] Result<int> addTile(const std::string& name, const TerrainSplatmap& splatmap, double originX,
                                      double originZ, double width, double depth, bool worldMap = false);
    [[nodiscard]] Result<int> paint(const Heightmap& operationPaint, int targetLayer,
                                    const TerrainStampSettings& operationSettings,
                                    bool worldMapOperation = false);
    [[nodiscard]] Result<int> copyTile(const std::string& name, TerrainSplatmap& output) const;
    [[nodiscard]] Result<int> undo();
    [[nodiscard]] Result<int> redo();
    int getTileCount() const noexcept;
    int getLastChangedSamples() const noexcept;
    int getLastAffectedTiles() const noexcept;
    int getOperationCount() const noexcept;
    int getAppliedCount() const noexcept;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
}  // namespace eve::procgen