BuildingTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingAuthority.h"
#include "editing/EditableTarget.h"
#include "editing/EditingGizmo.h"
 
#include <array>
#include <map>
#include <string>
#include <vector>
 
namespace eve::building {
class PlacementWorld;
}
 
namespace eve::building_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 IEditableTarget=editing::IEditableTarget;
using Revision=editing::Revision; using RuleId=editing::RuleId;
using TargetDescriptor=editing::TargetDescriptor; using TargetId=editing::TargetId;
 
struct BuildingGarrisonMemberRecord {
    std::string id;
    std::string type;
    std::vector<std::string> tags;
};
 
struct BuildingInstanceSnapshot {
    int instanceId = 0;
    std::string buildingId;
    std::string placementKind = "cell";
    int edgeX = 0;
    int edgeY = 0;
    std::string edgeAxis = "horizontal";
    int cornerX = 0;
    int cornerY = 0;
    double freeRadius = 0.0;
    double freeHalfWidth = 0.0;
    double freeHalfHeight = 0.0;
    std::vector<double> freeFootprintVertices;
    int cellX = 0;
    int cellY = 0;
    int level = 0;
    double worldX = 0.0;
    double worldY = 0.0;
    double elevation = 0.0;
    std::string surfaceId;
    std::uint64_t surfaceRevision = 0;
    double surfaceNormalX = 0.0;
    double surfaceNormalY = 1.0;
    double surfaceNormalZ = 0.0;
    double surfaceTangentX = 1.0;
    double surfaceTangentY = 0.0;
    double surfaceTangentZ = 0.0;
    int surfaceSampleCount = 0;
    double surfaceMaxSlopeDegrees = 0.0;
    double surfaceHeightDelta = 0.0;
    double rotationDegrees = 0.0;
    std::string channel;
    std::map<std::string, std::string> properties;
    std::vector<std::string> tags;
    std::vector<BuildingGarrisonMemberRecord> garrison;
    std::uint64_t garrisonRevision = 0;
};
 
struct BuildingFootprintCell {
    int x = 0;
    int y = 0;
    bool inBounds = false;
    int occupant = 0;
    int terrain = 0;
};
 
struct BuildingEdgePathVertex {
    int x = 0;
    int y = 0;
};
 
struct BuildingEdgeCurvePoint {
    double x = 0.0;
    double y = 0.0;
};
 
struct BuildingEdgeCurvePreviewEdge {
    int x = 0;
    int y = 0;
    std::string axis;
};
 
struct BuildingEdgeCurveSurfaceSample {
    double worldX = 0.0;
    double worldY = 0.0;
    double worldZ = 0.0;
    double normalX = 0.0;
    double normalY = 1.0;
    double normalZ = 0.0;
};
 
struct BuildingEdgeCurvePreview {
    EditorStatus status = EditorStatus::Failed;
    Revision worldRevision = 0;
    std::vector<BuildingEdgeCurvePoint> controlPoints;
    std::vector<BuildingEdgePathVertex> sampledVertices;
    std::vector<BuildingEdgeCurvePreviewEdge> edges;
    std::string surfaceProviderName;
    std::string surfaceId;
    std::uint64_t surfaceRevision = 0;
    std::vector<BuildingEdgeCurveSurfaceSample> surfaceSamples;
    std::vector<EditorDiagnostic> diagnostics;
};
 
struct BuildingPlacementPreview {
    EditorStatus status = EditorStatus::Failed;
    Revision worldRevision = 0;
    int snappedCellX = 0;
    int snappedCellY = 0;
    double snappedWorldX = 0.0;
    double snappedWorldY = 0.0;
    double elevation = 0.0;
    double normalizedRotation = 0.0;
    std::vector<BuildingFootprintCell> cells;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_DOMAINS BuildingPlacementTarget final : public ::eve::editing::EditableTargetState,
                                                           public virtual IEditableTarget,
                                                           public IDomainOperationTarget,
                                                           public editing::IDomainOperationTargetStaging {
public:
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.building-placement"); }
    BuildingPlacementTarget(std::string id, building::PlacementWorld* world);
    BuildingPlacementTarget(BuildingPlacementTarget&&) noexcept;
    BuildingPlacementTarget& operator=(BuildingPlacementTarget&&) noexcept;
    BuildingPlacementTarget(const BuildingPlacementTarget&)            = delete;
    BuildingPlacementTarget& operator=(const BuildingPlacementTarget&) = delete;
    ~BuildingPlacementTarget();
    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;
 
    Result<BuildingInstanceSnapshot> instance(int instanceId) const;
    int nextAvailableInstanceId() const;
    BuildingPlacementPreview preview(const std::string& buildingId, double worldX, double worldY,
                                     double elevation, double rotationDegrees,
                                     int excludeInstanceId = 0) const;
    Result<DomainOperation> makePlace(const BuildingInstanceSnapshot& placed) const;
    Result<DomainOperation> makeMove(int instanceId, int cellX, int cellY,
                                            double rotationDegrees) const;
    Result<DomainOperation> makeMoveFree(int instanceId, double worldX, double worldY,
                                               double elevation,
                                               double rotationDegrees) const;
    Result<DomainOperation> makeReplace(int instanceId,
                                              const std::string& replacementBuildingId) const;
    Result<DomainOperation> makeRectangle(const std::string& buildingId, int minCellX,
                                                int minCellY, int maxCellX, int maxCellY,
                                                double rotationDegrees) const;
    Result<DomainOperation> makeBrush(const std::string& buildingId, int centerCellX,
                                            int centerCellY, int radius,
                                            double rotationDegrees) const;
    Result<DomainOperation>
    makeEdgePath(const std::string& buildingId,
                 const std::vector<BuildingEdgePathVertex>& vertices) const;
    Result<DomainOperation>
    makeEdgeCubicBezier(const std::string& buildingId,
                        const std::vector<BuildingEdgeCurvePoint>& controlPoints,
                        int subdivisions) const;
    Result<DomainOperation> makeEdgeCubicBezierOnSurface(
        const std::string& buildingId,
        const std::vector<BuildingEdgeCurvePoint>& controlPoints, int subdivisions,
        const std::string& surfaceName) const;
    BuildingEdgeCurvePreview previewEdgeCubicBezier(
        const std::string& buildingId,
        const std::vector<BuildingEdgeCurvePoint>& controlPoints, int subdivisions,
        int replacingMemberInstanceId = 0, const std::string& surfaceName = {}) const;
    editing::GizmoSnapshot edgeCubicBezierGizmo(
        const std::string& buildingId,
        const std::vector<BuildingEdgeCurvePoint>& controlPoints, int subdivisions,
        int level = 0, int replacingMemberInstanceId = 0,
        const std::string& surfaceName = {}) const;
    Result<DomainOperation> makeUpdateEdgeCubicBezier(
        int memberInstanceId, const std::vector<BuildingEdgeCurvePoint>& controlPoints,
        int subdivisions) const;
    Result<BuildingEdgeCurvePoint> curveLogicalPointFromWorld(
        double worldX, double worldY, double worldZ) const;
    Result<DomainOperation> makeRemove(int instanceId) const;
    EditorValue snapshotValue() const;
 
private:
    BuildingPlacementTarget(std::string id, std::unique_ptr<building::PlacementWorld> world,
                            unsigned long long revision);
    std::string id_;
    building::PlacementWorld* world_ = nullptr;
    std::unique_ptr<building::PlacementWorld> ownedWorld_;
};
 
struct BuildingEdgeCurveDragPreview {
    EditorStatus status = EditorStatus::Failed;
    int controlPointIndex = -1;
    BuildingEdgeCurvePreview curve;
    editing::GizmoSnapshot gizmo;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_DOMAINS BuildingEdgeCurveDragSession {
public:
    BuildingEdgeCurveDragSession(BuildingPlacementTarget* target, std::string buildingId,
                                 int memberInstanceId,
                                 std::vector<BuildingEdgeCurvePoint> controlPoints,
                                 int subdivisions, std::string surfaceName = {});
    Result<BuildingEdgeCurveDragPreview> beginDrag(
        double rayOriginX, double rayOriginY, double rayOriginZ,
        double rayDirectionX, double rayDirectionY, double rayDirectionZ);
    Result<BuildingEdgeCurveDragPreview> updateDrag(
        double rayOriginX, double rayOriginY, double rayOriginZ,
        double rayDirectionX, double rayDirectionY, double rayDirectionZ);
    Result<DomainOperation> finishDrag();
    void cancelDrag();
    bool isDragging() const { return dragging_; }
    int activeControlPointIndex() const { return activeControlPointIndex_; }
 
private:
    Result<BuildingEdgeCurveDragPreview> previewCurrent() const;
    BuildingPlacementTarget* target_ = nullptr;
    std::string buildingId_;
    int memberInstanceId_ = 0;
    std::vector<BuildingEdgeCurvePoint> controls_;
    int subdivisions_ = 0;
    std::string surfaceName_;
    Revision baseRevision_ = 0;
    int activeControlPointIndex_ = -1;
    std::array<double, 3> dragPlanePoint_{0.0, 0.0, 0.0};
    std::array<double, 3> dragPlaneNormal_{0.0, 0.0, 1.0};
    bool dragging_ = false;
    bool lastPreviewValid_ = false;
};
 
}  // namespace eve::building_editing