ArchSpaceTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "archspace/ArchSpaceDocument.h"
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingGizmo.h"
#include "editing/EditingProperty.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace eve::archspace_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 EditorGizmoSnapshot           = editing::GizmoSnapshot;
using EditorGizmoPrimitive          = editing::GizmoPrimitive;
using editing::validatePropertyValue;
 
class EVENGINE_API_DOMAINS ArchSpaceDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                           public virtual IEditableTarget,
                                                           public IDomainOperationTarget,
                                                           public IDomainOperationTargetStaging,
                                                           public IPropertyProvider,
                                                           public IEditingSnapshotProvider {
public:
    explicit ArchSpaceDocumentTarget(std::string id);
 
    static CapabilityId propertyCapabilityId() { return CapabilityId("eve.editor.target.archspace-properties"); }
 
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void*                                   queryCapability(const CapabilityId& capability) override;
    Result<void>                      applyDomainOperation(const DomainOperation& operation) override;
    std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    Result<void>            commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
    eve::Result<eve::Revision>    currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema                schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult            read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                          const EditorValue& value, PropertySetMode mode) const override;
    Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                            const PropertyPath&      path) const override;
 
    Result<DomainOperation> makeBootstrap(const std::string& siteId, const std::string& buildingId,
                                                const std::string& levelId, double levelHeight = 3.0) const;
    Result<DomainOperation> makeCreateRectRoom(const std::string& levelId, const std::string& roomId,
                                                     std::string roomName, double originX, double originZ, double sizeX,
                                                     double sizeZ, double wallHeight = 3.0, double wallThickness = 0.2,
                                                     double slabThickness = 0.2) const;
    Result<DomainOperation> makeCreateWall(const std::string& levelId, const std::string& wallId,
                                                 std::string wallName, archspace::Vec2 start, archspace::Vec2 end,
                                                 double height = 3.0, double thickness = 0.2) const;
    Result<DomainOperation> makeCreateOpening(const std::string& wallId, const std::string& openingId,
                                                    archspace::OpeningKind kind, double t, double width, double height,
                                                    double sill = 0.0) const;
    Result<DomainOperation> makePlaceItem(const std::string& levelId, const std::string& itemId,
                                                std::string catalogId, archspace::Vec3 position,
                                                double yawDegrees = 0.0) const;
    Result<DomainOperation> makeDeleteNode(const ObjectId& id) const;
 
    [[nodiscard]] const archspace::Document&    document() const { return document_; }
    [[nodiscard]] std::vector<EditorDiagnostic> validate() const;
    [[nodiscard]] EditorValue                   snapshotValue() const override;
    Result<void>                          loadSnapshot(const EditorValue& snapshot);
    [[nodiscard]] Result<EditorGizmoSnapshot> gizmo() const;
    [[nodiscard]] archspace::MeshBake bakeMesh() const { return document_.bakeMesh(); }
 
private:
    bool                          matches(const SelectionSnapshot& selection) const;
    EditorValue                   contentValue() const;
    Result<DomainOperation> replacement(EditorValue content, std::string property = {}) const;
    Result<void>            installContent(const EditorValue& content);
    const archspace::Node* selectedNode(const SelectionSnapshot& selection) const;
 
    std::string         id_;
    archspace::Document document_;
};
 
}  // namespace eve::archspace_editing