MaterialTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "editing/EditableTarget.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace eve::material_editing {
 
using editing::CapabilityId; using editing::DiagnosticSeverity; using editing::DomainOperation;
using editing::EditRegion; 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::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;
 
class EVENGINE_API_BACKENDS MaterialDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                           public virtual IEditableTarget,
                                                           public IDomainOperationTarget,
                                                           public IDomainOperationTargetStaging,
                                                           public eve::editing::IEditingSnapshotProvider,
                                                           public IPropertyProvider {
public:
    explicit MaterialDocumentTarget(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;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] 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;
 
    EditorValue snapshotValue() const override;
    Result<void> loadSnapshot(const EditorValue& snapshot);
    std::vector<EditorDiagnostic> validate() const;
 
private:
    static PropertySchema materialSchema();
    static std::map<std::string, EditorValue> defaults();
    static Result<void> validateAssignment(const PropertyDescriptor& descriptor,
                                                 const EditorValue& value);
    bool selectionMatches(const SelectionSnapshot& selection) const;
 
    std::string                        id_;
    std::map<std::string, EditorValue> values_;
};
 
class IMaterialRuntimeSink {
public:
    virtual ~IMaterialRuntimeSink() = default;
    virtual Result<void> publish(const MaterialDocumentTarget& candidate) = 0;
};
 
class EVENGINE_API_BACKENDS MaterialPublishingTarget final : public IDomainOperationTarget,
                                                             public IDomainOperationTargetStaging {
public:
    MaterialPublishingTarget(std::string id, IMaterialRuntimeSink* 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(); }
    TargetDescriptor describe() const override;
    void* queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(
        std::unique_ptr<IDomainOperationTarget> candidate) override;
    MaterialDocumentTarget& authoringTarget() { return document_; }
    const MaterialDocumentTarget& authoringTarget() const { return document_; }
    [[nodiscard]] Result<void> reloadSnapshot(const EditorValue& snapshot);
 
private:
    MaterialDocumentTarget document_;
    IMaterialRuntimeSink* sink_ = nullptr;
    bool staging_ = false;
};
 
}  // namespace eve::material_editing
 
namespace eve::graphics {
class Renderable3D;
class Texture;
class Shader;
}
 
namespace eve::material_editing {
 
class IMaterialRuntimeAssetResolver {
public:
    virtual ~IMaterialRuntimeAssetResolver() = default;
    virtual Result<graphics::Texture*> resolveTexture(const std::string& asset) const = 0;
    virtual Result<graphics::Shader*> resolveShader(const std::string& asset) const = 0;
};
 
class EVENGINE_API_WORLD Renderable3DMaterialRuntimeSink final : public IMaterialRuntimeSink {
public:
    Renderable3DMaterialRuntimeSink(graphics::Renderable3D* renderable,
                                    const IMaterialRuntimeAssetResolver* assets);
    ~Renderable3DMaterialRuntimeSink() override;
    Result<void> publish(const MaterialDocumentTarget& candidate) override;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::material_editing