TerrainTreePlacement.h

浏览该文件的文档.

#pragma once
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include "common/Result.h"
 
namespace eve::procgen {
class Heightmap;
class PointSet;
struct TerrainMultiTileReport;
struct TerrainStampSettings;
 
enum class TerrainTreeScaleMode : std::uint8_t { Fixed, Fitness, Random, FitnessRandomized };
 
enum class TerrainTreeYOffsetMode : std::uint8_t { TerrainHeight, SeaLevel, Custom };
 
struct TerrainTreePlacementSettings {
    float originX = 0, originZ = 0, width = 1, depth = 1, heightScale = 1;
    float spacing = 10, spawnDensity = 1, jitterPercent = 0.5F;
    float failureRate = 0, minimumFitness = 0.5F;
    bool  snapToTerrain = true;
    TerrainTreeYOffsetMode yOffsetMode = TerrainTreeYOffsetMode::TerrainHeight;
    float seaLevel = 0, customOffset = 0, minimumYOffset = -2, maximumYOffset = 2;
    TerrainTreeScaleMode scaleMode = TerrainTreeScaleMode::Fitness;
    float minimumWidth = 0.75F, maximumWidth = 1.5F;
    float minimumHeight = 0.75F, maximumHeight = 1.5F;
    float widthRandomPercentage = 0.5F, heightRandomPercentage = 0.5F;
    float healthyR = 1, healthyG = 1, healthyB = 1, healthyA = 1;
    float dryR = 1, dryG = 1, dryB = 1, dryA = 1;
    float bendFactor = 0, boundsRadius = 1;
    std::int32_t seed = 1;
    std::uint64_t namespaceId = 1;
    int maxPoints = 1000000;
    std::string asset;
};
 
struct TerrainTreeRescaleSettings {
    TerrainTreeScaleMode scaleMode = TerrainTreeScaleMode::Fitness;
    float previousMinimumWidth = 0.75F, previousMaximumWidth = 1.5F;
    float previousMinimumHeight = 0.75F, previousMaximumHeight = 1.5F;
    float minimumWidth = 0.75F, maximumWidth = 1.5F;
    float minimumHeight = 0.75F, maximumHeight = 1.5F;
    float bendFactor = 0, boundsRadius = 1;
    std::string asset;
};
 
enum class TerrainTreeOperationMode : std::uint8_t { Add, Replace, Remove };
 
struct TerrainTreeTile {
    std::string name;
    PointSet* trees = nullptr;
    const Heightmap* heights = nullptr;
    double originX = 0, originZ = 0, width = 1, depth = 1;
    int treeResolutionX = 0, treeResolutionY = 0;
    bool worldMap = false;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<TerrainMultiTileReport> applyTerrainTreesMultiTile(
    const std::vector<TerrainTreeTile>& tiles, const Heightmap& operationFitness,
    const TerrainTreePlacementSettings& settings, const TerrainStampSettings& operationSettings,
    TerrainTreeOperationMode mode, bool worldMapOperation = false,
    const std::vector<std::string>& validTerrainNames = {});
 
class EVENGINE_API_DOMAINS TerrainMultiTreeWorkspace {
public:
    TerrainMultiTreeWorkspace();
    ~TerrainMultiTreeWorkspace();
    TerrainMultiTreeWorkspace(TerrainMultiTreeWorkspace&&) noexcept;
    TerrainMultiTreeWorkspace& operator=(TerrainMultiTreeWorkspace&&) noexcept;
    TerrainMultiTreeWorkspace(const TerrainMultiTreeWorkspace&) = delete;
    TerrainMultiTreeWorkspace& operator=(const TerrainMultiTreeWorkspace&) = delete;
    [[nodiscard]] Result<int> addTile(const std::string& name, const PointSet& trees, const Heightmap& heights,
                                      double originX, double originZ, double width, double depth,
                                      int treeResolutionX, int treeResolutionY, bool worldMap = false);
    [[nodiscard]] Result<int> apply(const Heightmap& operationFitness,
                                    const TerrainTreePlacementSettings& settings,
                                    const TerrainStampSettings& operationSettings, TerrainTreeOperationMode mode,
                                    bool worldMapOperation = false);
    [[nodiscard]] Result<int> copyTile(const std::string& name, PointSet& 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_;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> exportTerrainTreePoints(PointSet& output, const Heightmap& fitness,
                                                                       const Heightmap&                    heights,
                                                                       const TerrainTreePlacementSettings& settings);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> removeTerrainTreePoints(PointSet& output, const PointSet& input,
                                                                       const Heightmap&                    fitness,
                                                                       const TerrainTreePlacementSettings& settings);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> rescaleTerrainTreePoints(PointSet& output, const PointSet& input,
                                                                        const TerrainTreeRescaleSettings& settings);
}  // namespace eve::procgen