StylizeTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Texture;
class Canvas;
}  // namespace eve::graphics
namespace eve::stylize {
class StyleInstance;
class StyleRecipe;
}  // namespace eve::stylize
 
namespace eve::stylize_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::ObjectId;
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;
 
struct StylizePassValue {
    ObjectId                      id;
    std::string                   style;
    bool                          enabled  = true;
    int                           priority = 0;
    std::map<std::string, double> overrides;
};
 
class EVENGINE_API_DOMAINS StylizeRecipeTarget final : public ::eve::editing::EditableTargetState,
                                                       public virtual IEditableTarget,
                                                       public IDomainOperationTarget,
                                                       public IDomainOperationTargetStaging,
                                                       public IPropertyProvider {
public:
    explicit StylizeRecipeTarget(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;
    Result<DomainOperation> makeCreate(const ObjectId& id, const std::string& style) const;
    Result<DomainOperation> makeDelete(const ObjectId& id) const;
    Result<DomainOperation> makeMove(const ObjectId& id, std::size_t index) const;
    std::vector<StylizePassValue> passes() const;
    std::vector<EditorDiagnostic> validate() const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    bool                                 matches(const SelectionSnapshot& selection) const;
    EditorValue                          contentValue() const;
    Result<DomainOperation>        replacement(EditorValue payload, std::string property = {}) const;
    std::string                          id_;
    std::map<ObjectId, StylizePassValue> passes_;
    std::vector<ObjectId>                order_;
};
 
class EVENGINE_API_DOMAINS StylizeRecipeRuntime {
public:
    StylizeRecipeRuntime();
    ~StylizeRecipeRuntime();
    Result<void> publish(const StylizeRecipeTarget& document, graphics::Graphics* graphics);
    Result<void> apply(graphics::Graphics* graphics, graphics::Texture* source, graphics::Canvas* destination,
                             Revision expectedRevision) const;
    Revision revision() const { return revision_; }
 
private:
    std::vector<std::unique_ptr<stylize::StyleInstance>> instances_;
    std::unique_ptr<stylize::StyleRecipe>                recipe_;
    graphics::Graphics*                                  graphics_ = nullptr;
    Revision                                             revision_ = 0;
};
 
}  // namespace eve::stylize_editing