MeshVfxTarget.h

浏览该文件的文档.

#pragma once
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace eve::stylize {
struct MeshVfxAsset;
class MeshVfxAssetInstance;
}
 
namespace eve::stylize_editing {
 
using editing::CapabilityId;
using editing::DomainOperation;
using editing::EditRegion;
using editing::IDomainOperationTarget;
using editing::IDomainOperationTargetStaging;
using editing::IEditableTarget;
using editing::IPropertyProvider;
using editing::PropertyPath;
using editing::PropertyReadResult;
using editing::PropertySchema;
using editing::PropertySetMode;
using editing::Revision;
using editing::SelectionSnapshot;
using editing::TargetDescriptor;
using editing::TargetId;
using EditorValue = editing::Value;
using editing::Result;
 
class EVENGINE_API_DOMAINS MeshVfxAssetTarget final : public ::eve::editing::EditableTargetState,
                                                      public virtual IEditableTarget,
                                                      public IDomainOperationTarget,
                                                      public IDomainOperationTargetStaging,
                                                      public IPropertyProvider {
public:
    explicit MeshVfxAssetTarget(std::string id);
    ~MeshVfxAssetTarget();
    MeshVfxAssetTarget(const MeshVfxAssetTarget& other);
    MeshVfxAssetTarget& operator=(const MeshVfxAssetTarget& other);
 
    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;
 
    [[nodiscard]] const stylize::MeshVfxAsset& asset() const noexcept;
    [[nodiscard]] EditorValue snapshotValue() const;
    [[nodiscard]] Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    bool matches(const SelectionSnapshot& selection) const;
    std::string canonicalJson() const;
 
    std::string                            id_;
    std::unique_ptr<stylize::MeshVfxAsset> asset_;
};
 
class EVENGINE_API_DOMAINS MeshVfxPreviewRuntime {
public:
    MeshVfxPreviewRuntime();
    ~MeshVfxPreviewRuntime();
    [[nodiscard]] Result<void> publish(const MeshVfxAssetTarget& document);
    [[nodiscard]] stylize::MeshVfxAssetInstance* instance() noexcept { return instance_.get(); }
    [[nodiscard]] Revision revision() const noexcept { return revision_; }
 
private:
    std::unique_ptr<stylize::MeshVfxAssetInstance> instance_;
    Revision revision_ = 0;
};
 
}  // namespace eve::stylize_editing