EditorBuildingTarget.h

浏览该文件的文档.

#pragma once
 
#include "building/editing/BuildingTarget.h"
#include "common/Export.h"
#include "editor/EditorPresentation.h"
#include "editor/EditorTool.h"
 
#include <memory>
#include <optional>
 
namespace eve::editor {
using BuildingGarrisonMemberRecord=eve::building_editing::BuildingGarrisonMemberRecord;
using BuildingInstanceSnapshot=eve::building_editing::BuildingInstanceSnapshot;
using BuildingFootprintCell=eve::building_editing::BuildingFootprintCell;
using BuildingPlacementPreview=eve::building_editing::BuildingPlacementPreview;
using BuildingPlacementTarget=eve::building_editing::BuildingPlacementTarget;
 
struct BuildingViewportRay {
    std::array<double, 3> origin{0.0, 0.0, 0.0};
    std::array<double, 3> direction{0.0, 0.0, -1.0};
};
 
class IBuildingViewportAdapter {
public:
    virtual ~IBuildingViewportAdapter() = default;
 
    virtual editing::Result<BuildingViewportRay> pointerRay(
        const EditorPointerEvent& event) const = 0;
    virtual editing::Result<OverlayPoint> projectWorld(
        const std::array<double, 3>& world) const = 0;
};
 
struct BuildingEdgeCurveToolSelection {
    std::string buildingId;
    int memberInstanceId = 0;
    std::vector<building_editing::BuildingEdgeCurvePoint> controlPoints;
    int subdivisions = 16;
    std::string surfaceName;
};
 
class EVENGINE_API_EDITORS BuildingEdgeCurveTool final : public IEditorTool {
public:
    BuildingEdgeCurveTool(IBuildingViewportAdapter* viewport,
                          editing::IEditAuthority* authority);
 
    const ToolDescriptor& descriptor() const override { return descriptor_; }
    void setViewportAdapter(IBuildingViewportAdapter* viewport);
    void setAuthority(editing::IEditAuthority* authority);
    [[nodiscard]] editing::Result<void> setSelection(BuildingEdgeCurveToolSelection selection);
    void clearSelection();
 
    ToolResponse pointerEvent(EditorContext& context,
                              const EditorPointerEvent& event) override;
    void deactivate(EditorContext& context) override;
    void cancel(EditorContext& context) override;
    void drawOverlay(EditorContext& context, IEditorOverlay& overlay) override;
 
    bool isDragging() const;
    const std::optional<building_editing::BuildingEdgeCurveDragPreview>& preview() const {
        return preview_;
    }
    const std::optional<editing::TransactionReceipt>& lastReceipt() const {
        return lastReceipt_;
    }
    editing::Status lastStatus() const { return lastStatus_; }
    const std::vector<editing::Diagnostic>& diagnostics() const { return diagnostics_; }
 
private:
    void recordFailure(const editing::Status& status,
                       const std::vector<editing::Diagnostic>& diagnostics);
    void recordPreview(building_editing::BuildingEdgeCurveDragPreview preview);
    ToolResponse begin(EditorContext& context, const EditorPointerEvent& event);
    ToolResponse move(const EditorPointerEvent& event);
    ToolResponse finish(EditorContext& context, const EditorPointerEvent& event);
 
    ToolDescriptor descriptor_{"building.edge-curve", "Edit Building Curve", {}};
    IBuildingViewportAdapter* viewport_ = nullptr;
    editing::IEditAuthority* authority_ = nullptr;
    std::optional<BuildingEdgeCurveToolSelection> selection_;
    std::unique_ptr<building_editing::BuildingEdgeCurveDragSession> drag_;
    std::optional<building_editing::BuildingEdgeCurveDragPreview> preview_;
    std::optional<editing::TransactionReceipt> lastReceipt_;
    editing::Status lastStatus_ = editing::Status::NotFound;
    std::vector<editing::Diagnostic> diagnostics_;
    std::uint64_t transactionSequence_ = 0;
};
}