VoxelCatalog.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
 
#include <array>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::voxel_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;
 
inline constexpr int kVoxelModelMaxSize = 32;
inline constexpr int kVoxelModelMaxOccupied = 4096;
 
enum class VoxelSocketKind { None, Symmetric, Male, Female };
 
enum class VoxelCellFill { Empty, Partial, Filled };
 
struct VoxelSocket {
    std::string     tag;
    VoxelSocketKind kind = VoxelSocketKind::None;
};
 
struct VoxelCoord {
    int x = 0;
    int y = 0;
    int z = 0;
};
 
struct VoxelModelValue {
    ObjectId                   id;
    std::string                name;
    int                        sizeX = 8;
    int                        sizeY = 8;
    int                        sizeZ = 8;
    std::array<VoxelSocket, 6> sockets{};
    std::vector<VoxelCoord>    voxels;
};
 
struct VoxelPick {
    bool hit       = false;
    bool canAttach = false;
    int  hitX      = 0;
    int  hitY      = 0;
    int  hitZ      = 0;
    int  prevX     = 0;
    int  prevY     = 0;
    int  prevZ     = 0;
};
 
[[nodiscard]] VoxelSocketKind voxelSocketKindFromName(std::string_view name);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION const char* voxelSocketKindName(VoxelSocketKind kind);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION bool canJoinVoxelSockets(const VoxelSocket& a, const VoxelSocket& b);
 
[[nodiscard]] int voxelOppositeFace(int face);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION VoxelCellFill voxelClassifyModelFill(const VoxelModelValue& model);
 
[[nodiscard]] bool isVoxelModelOccupied(const VoxelModelValue& model, int x, int y, int z);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION VoxelPick pickVoxelModel(const VoxelModelValue& model, float ox, float oy,
                                                                  float oz, float dx, float dy, float dz,
                                                                  float maxDistance);
 
class EVENGINE_API_ORCHESTRATION VoxelCatalogTarget final : public ::eve::editing::EditableTargetState,
                                                            public virtual IEditableTarget,
                                                            public IDomainOperationTarget,
                                                            public IDomainOperationTargetStaging,
                                                            public IPropertyProvider,
                                                            public IEditingSnapshotProvider {
public:
    explicit VoxelCatalogTarget(std::string id);
 
    static CapabilityId propertyCapabilityId() { return CapabilityId("eve.editor.target.voxel-catalog-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;
 
    [[nodiscard]] Result<DomainOperation> makeCreateModel(const VoxelModelValue&) const;
    [[nodiscard]] Result<DomainOperation> makeDeleteModel(const ObjectId&) const;
    [[nodiscard]] Result<DomainOperation> makeSetVoxel(const ObjectId& model, int x, int y, int z,
                                                             bool occupied) const;
 
    const std::vector<VoxelModelValue>& models() const { return models_; }
    const VoxelModelValue* findModel(const ObjectId&) const;
 
    std::vector<EditorDiagnostic> validate() const;
    EditorValue                   snapshotValue() const override;
    Result<void>            loadSnapshot(const EditorValue&);
 
    [[nodiscard]] std::vector<ObjectId> hullJoinPartners(const ObjectId& model, int face) const;
 
private:
    bool                          matches(const SelectionSnapshot&) const;
    EditorValue                   contentValue() const;
    Result<DomainOperation> replacement(EditorValue, std::string = {}) const;
    VoxelModelValue* findModelMut(const ObjectId&);
 
    std::string                  id_;
    std::vector<VoxelModelValue> models_;
};
 
}  // namespace eve::voxel_editing