BiomeTarget.h

浏览该文件的文档.

#pragma once
 
#include <memory>
#include <string>
#include <vector>
#include "common/Export.h"
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
 
namespace eve::procgen {
class SpatialData;
class BiomeRules;
class PointSet;
}  // namespace eve::procgen
namespace eve::biome_editing {
using CapabilityId       = editing::CapabilityId;
using DiagnosticSeverity = editing::DiagnosticSeverity;
using DomainOperation    = editing::DomainOperation;
using EditRegion         = editing::EditRegion;
using EditorDiagnostic   = editing::Diagnostic;
using editing::Result;
using EditorStatus                  = editing::Status;
using EditorValue                   = editing::Value;
using IDomainOperationTarget        = editing::IDomainOperationTarget;
using IDomainOperationTargetStaging = editing::IDomainOperationTargetStaging;
using IEditableTarget               = editing::IEditableTarget;
using IEditingSnapshotProvider      = editing::IEditingSnapshotProvider;
using IPropertyProvider             = editing::IPropertyProvider;
using ObjectId                      = editing::ObjectId;
using PropertyDescriptor            = editing::PropertyDescriptor;
using PropertyFlag                  = editing::PropertyFlag;
using PropertyPath                  = editing::PropertyPath;
using PropertyReadResult            = editing::PropertyReadResult;
using PropertyReadState             = editing::PropertyReadState;
using PropertySchema                = editing::PropertySchema;
using PropertySetMode               = editing::PropertySetMode;
using PropertyType                  = editing::PropertyType;
using Revision                      = editing::Revision;
using RuleId                        = editing::RuleId;
using SelectionSnapshot             = editing::SelectionSnapshot;
using TargetDescriptor              = editing::TargetDescriptor;
using TargetId                      = editing::TargetId;
using editing::validatePropertyValue;
    ObjectId    id;
    std::string asset;
    float       weight = 1, minScale = 1, maxScale = 1;
    bool        randomYaw = true;
};
    ObjectId                     id;
    std::string                  name, spatialAsset;
    int                          priority = 0;
    float                        density  = 1;
    std::vector<BiomeAssetValue> assets;
};
class EVENGINE_API_ORCHESTRATION BiomeDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                             public virtual IEditableTarget,
                                                             public IDomainOperationTarget,
                                                             public IDomainOperationTargetStaging,
                                                             public IPropertyProvider,
                                                             public IEditingSnapshotProvider {
public:
    explicit BiomeDocumentTarget(std::string id);
    static CapabilityId                     propertyCapabilityId() {
        return CapabilityId("eve.editor.target.biome-properties");
    }
    TargetId                                targetId() const override { return TargetId(id_); }
    TargetDescriptor                        describe() const override;
    void*                                   queryCapability(const CapabilityId&) override;
    Result<void>                      applyDomainOperation(const DomainOperation&) override;
    std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    Result<void>                      commitDomainState(std::unique_ptr<IDomainOperationTarget>) override;
    eve::Result<eve::Revision>              currentRevision(const SelectionSnapshot&) const override;
    PropertySchema                          schema(const SelectionSnapshot&) const override;
    PropertyReadResult                      read(const SelectionSnapshot&, const PropertyPath&) const override;
    Result<DomainOperation>           makeSet(const SelectionSnapshot&, const PropertyPath&, const EditorValue&,
                                                    PropertySetMode) const override;
    Result<DomainOperation>           makeReset(const SelectionSnapshot&, const PropertyPath&) const override;
    Result<DomainOperation>           makeCreateLayer(const BiomeLayerValue&) const;
    Result<DomainOperation>           makeDeleteLayer(const ObjectId&) const;
    Result<DomainOperation>           makeCreateAsset(const ObjectId& layer, const BiomeAssetValue&) const;
    Result<DomainOperation>           makeDeleteAsset(const ObjectId&) const;
    Result<DomainOperation>           makeSetExclusions(std::vector<std::string>) const;
    const std::vector<BiomeLayerValue>&     layers() const { return layers_; }
    const std::vector<std::string>&         exclusions() const { return exclusions_; }
    std::vector<EditorDiagnostic>           validate() const;
    EditorValue                             snapshotValue() const override;
    Result<void>                      loadSnapshot(const EditorValue&);
 
private:
    bool                          matches(const SelectionSnapshot&) const;
    EditorValue                   contentValue() const;
    Result<DomainOperation> replacement(EditorValue, std::string = {}) const;
    std::string                   id_;
    std::vector<BiomeLayerValue>  layers_;
    std::vector<std::string>      exclusions_;
};
class IBiomeSpatialResolver {
public:
    virtual ~IBiomeSpatialResolver() = default;
    virtual Result<procgen::SpatialData*> resolve(const std::string&) const = 0;
};
class EVENGINE_API_ORCHESTRATION BiomeDocumentRuntime {
public:
    BiomeDocumentRuntime();
    ~BiomeDocumentRuntime();
    Result<void> publish(const BiomeDocumentTarget&, const IBiomeSpatialResolver&);
    Result<std::unique_ptr<procgen::PointSet>> preview(procgen::SpatialData* domain, float spacing,
                                                             std::uint32_t seed, float jitter,
                                                             Revision expectedRevision);
    procgen::BiomeRules* rules() const { return rules_.get(); }
    Revision                                         revision() const { return revision_; }
 
private:
    std::unique_ptr<procgen::BiomeRules> rules_;
    Revision                             revision_ = 0;
};
}  // namespace eve::biome_editing