DecalTarget.h

浏览该文件的文档.

#pragma once
 
#include "editing/EditingGizmo.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "editing/EditableTarget.h"
 
#include <map>
#include <string>
#include <utility>
 
namespace eve::graphics { class Texture; }
namespace eve::decal { class DecalManager; }
 
namespace eve::decal_editing {
 
using editing::CapabilityId; using editing::DiagnosticSeverity; using editing::DomainOperation;
using editing::EditRegion; using editing::GizmoSnapshot; using editing::IDomainOperationTarget;
using editing::IDomainOperationTargetStaging; using editing::IEditableTarget; using editing::IPropertyProvider;
using editing::PropertyDescriptor; using editing::PropertyFlag; using editing::PropertyPath;
using editing::PropertyReadResult; using editing::PropertyReadState; using editing::PropertySchema;
using editing::PropertySetMode; using editing::PropertyType; using editing::Revision; using editing::RuleId;
using editing::SelectionSnapshot; using editing::TargetDescriptor; using editing::TargetId;
using editing::Result;
using EditorStatus=editing::Status; using EditorValue=editing::Value; using EditorDiagnostic=editing::Diagnostic;
using EditorGizmoSnapshot=editing::GizmoSnapshot; using EditorGizmoPrimitive=editing::GizmoPrimitive;
 
class EVENGINE_API_DOMAINS DecalDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                       public virtual IEditableTarget,
                                                       public IDomainOperationTarget,
                                                       public IDomainOperationTargetStaging,
                                                       public IPropertyProvider {
public:
    explicit DecalDocumentTarget(std::string id);
    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;
    const EditorValue* value(const std::string& path) const;
    std::vector<EditorDiagnostic> validate() const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
private:
    bool matches(const SelectionSnapshot& selection) const;
    static PropertySchema decalSchema();
    static std::map<std::string,EditorValue> defaults();
    std::string                              id_;
    std::map<std::string,EditorValue> values_;
};
 
class IDecalRuntimeAssetResolver {
public:
    virtual ~IDecalRuntimeAssetResolver() = default;
    virtual Result<graphics::Texture*> texture(const std::string& asset) const = 0;
};
 
class IDecalRuntimeSink {
public:
    virtual ~IDecalRuntimeSink() = default;
    virtual Result<void> publish(const DecalDocumentTarget& document) = 0;
};
 
class EVENGINE_API_DOMAINS DecalRuntimeBinding final : public IDecalRuntimeSink {
public:
    DecalRuntimeBinding(decal::DecalManager* manager, const IDecalRuntimeAssetResolver* assets)
        : manager_(manager), assets_(assets) {}
    Result<void> publish(const DecalDocumentTarget& document) override;
    Result<void> clear();
    int runtimeId() const { return runtimeId_; }
private:
    decal::DecalManager* manager_=nullptr; const IDecalRuntimeAssetResolver* assets_=nullptr;
    int runtimeId_=0;
};
 
class EVENGINE_API_DOMAINS DecalPublishingTarget final : public IDomainOperationTarget,
                                                         public IDomainOperationTargetStaging {
public:
    DecalPublishingTarget(std::string id, IDecalRuntimeSink* sink)
        : document_(std::move(id)), sink_(sink) {}
    TargetId targetId() const override { return TargetId(document_.targetId()); }
    std::uint64_t revision() const override { return document_.revision(); }
    EditRegion dirtyRegion() const override { return document_.dirtyRegion(); }
    void clearDirtyRegion() override { document_.clearDirtyRegion(); }
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    Result<void> commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
    DecalDocumentTarget& authoringTarget() { return document_; }
    const DecalDocumentTarget& authoringTarget() const { return document_; }
private:
    DecalDocumentTarget document_; IDecalRuntimeSink* sink_=nullptr; bool staging_=false;
};
 
class EVENGINE_API_DOMAINS DecalGizmoPreviewService {
public:
    EditorGizmoSnapshot build(const DecalDocumentTarget& document) const;
};
 
}  // namespace eve::decal_editing