TerrainObjectPlacement.h

浏览该文件的文档.

#pragma once
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include "common/Result.h"
 
namespace eve::procgen {
class Heightmap;
class PointSet;
struct TerrainStampSettings;
struct TerrainMultiTileReport;
 
enum class TerrainObjectScaleMode : std::uint8_t { Fixed, Random, Fitness, FitnessRandomized };
enum class TerrainObjectYOffsetMode : std::uint8_t { TerrainHeight, SeaLevel, Custom };
enum class TerrainObjectOperationMode : std::uint8_t { Add, Replace, Remove };
 
struct TerrainObjectInstanceSettings {
    std::string asset;
    int minimumInstances = 1, maximumInstances = 1;
    float failureRate = 0;
    float minimumOffsetX = 0, maximumOffsetX = 0;
    float minimumOffsetY = 0, maximumOffsetY = 0;
    float minimumOffsetZ = 0, maximumOffsetZ = 0;
    TerrainObjectYOffsetMode yOffsetMode = TerrainObjectYOffsetMode::TerrainHeight;
    float customOffset = 0;
    TerrainObjectScaleMode scaleMode = TerrainObjectScaleMode::Fixed;
    bool commonScale = true;
    float minimumScale = 1, maximumScale = 1;
    float minimumScaleX = 1, maximumScaleX = 1;
    float minimumScaleY = 1, maximumScaleY = 1;
    float minimumScaleZ = 1, maximumScaleZ = 1;
    float scaleRandomPercentage = 0;
    float scaleRandomPercentageX = 0, scaleRandomPercentageY = 0, scaleRandomPercentageZ = 0;
    float minimumRotationX = 0, maximumRotationX = 0;
    float minimumRotationY = 0, maximumRotationY = 0;
    float minimumRotationZ = 0, maximumRotationZ = 0;
    bool yOffsetAlongSlope = false;
    bool alignForwardToSlope = false;
    bool rotateToSlope = false;
};
 
struct EVENGINE_API_DOMAINS TerrainObjectPlacementSettings {
    float originX = 0, originZ = 0, width = 1, depth = 1, heightScale = 1;
    float spacing = 10, spawnDensity = 1, jitterPercent = 0.5F;
    float startOffsetX = 0, startOffsetZ = 0;
    float failureRate = 0, minimumFitness = 0.5F, minimumInstanceFitness = 0.5F;
    float minimumDirection = 0, maximumDirection = 360;
    float boundsRadius = 1, boundsCheckQuality = 100, prototypeScale = 1;
    bool boundsCollisionCheck = false;
    float seaLevel = 0;
    std::int32_t seed = 1;
    std::uint64_t namespaceId = 1;
    int maxPoints = 1000000;
    std::string prototype;
    std::vector<TerrainObjectInstanceSettings> instances;
    [[nodiscard]] Result<int> addInstance(const TerrainObjectInstanceSettings& instance);
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> exportTerrainObjectPoints(
    PointSet& output, const Heightmap& fitness, const Heightmap& heights,
    const TerrainObjectPlacementSettings& settings);
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<int> removeTerrainObjectPoints(PointSet& output, const PointSet& input,
                                                                         const Heightmap&                      fitness,
                                                                         const TerrainObjectPlacementSettings& settings,
                                                                         float removalStrength);
 
struct TerrainObjectTile {
    std::string name;
    PointSet* objects = nullptr;
    const Heightmap* heights = nullptr;
    double originX = 0, originZ = 0, width = 1, depth = 1;
    int objectResolutionX = 0, objectResolutionY = 0;
    bool worldMap = false;
};
 
[[nodiscard]] Result<TerrainMultiTileReport> applyTerrainObjectsMultiTile(
    const std::vector<TerrainObjectTile>& tiles, const Heightmap& operationFitness,
    const TerrainObjectPlacementSettings& settings, const TerrainStampSettings& operationSettings,
    TerrainObjectOperationMode mode, bool worldMapOperation,
    const std::vector<std::string>& validTerrainNames = {});
 
class EVENGINE_API_DOMAINS TerrainMultiObjectWorkspace {
public:
    TerrainMultiObjectWorkspace();
    ~TerrainMultiObjectWorkspace();
    TerrainMultiObjectWorkspace(TerrainMultiObjectWorkspace&&) noexcept;
    TerrainMultiObjectWorkspace& operator=(TerrainMultiObjectWorkspace&&) noexcept;
    TerrainMultiObjectWorkspace(const TerrainMultiObjectWorkspace&) = delete;
    TerrainMultiObjectWorkspace& operator=(const TerrainMultiObjectWorkspace&) = delete;
    [[nodiscard]] Result<int> addTile(const std::string& name, const PointSet& objects, const Heightmap& heights,
                                     double originX, double originZ, double width, double depth,
                                     int resolutionX, int resolutionY, bool worldMap = false);
    [[nodiscard]] Result<int> apply(const Heightmap& fitness, const TerrainObjectPlacementSettings& settings,
                                   const TerrainStampSettings& operationSettings, TerrainObjectOperationMode mode,
                                   bool worldMapOperation = false);
    [[nodiscard]] Result<int> copyTile(const std::string& name, PointSet& output) const;
    [[nodiscard]] Result<int> undo();
    [[nodiscard]] Result<int> redo();
    [[nodiscard]] int getTileCount() const noexcept;
    [[nodiscard]] int getLastChangedSamples() const noexcept;
    [[nodiscard]] int getLastAffectedTiles() const noexcept;
    [[nodiscard]] int getOperationCount() const noexcept;
    [[nodiscard]] int getAppliedCount() const noexcept;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
}  // namespace eve::procgen