SpriteStackTarget.h

浏览该文件的文档.

#pragma once
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "spritestack/SpriteStack.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
}
namespace eve::image {
class ImageData;
}
namespace eve::model3d {
class ModelData;
}
namespace eve::spritestack {
class SpriteStack2D;
}
 
namespace eve::spritestack_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::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 SpriteStackAssetValue {
    std::string               sourceKind = "primitive";
    std::string               source     = "box";
    spritestack::SliceOptions bake;
    float                     displayWidth  = 64.f;
    float                     displayHeight = 64.f;
    float                     layerOffset   = 1.f;
    bool                      shadow        = true;
    float                     shadowOpacity = .3f;
    float                     outlineWidth  = 0.f;
};
 
class EVENGINE_API_DOMAINS SpriteStackDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                             public virtual IEditableTarget,
                                                             public IDomainOperationTarget,
                                                             public IDomainOperationTargetStaging,
                                                             public IPropertyProvider {
public:
    explicit SpriteStackDocumentTarget(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 SpriteStackAssetValue&  value() const { return value_; }
    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 content, std::string property) const;
    std::string                   id_;
    SpriteStackAssetValue         value_;
};
 
struct SpriteStackLayerArtifact {
    int           index = 0, width = 0, height = 0;
    std::uint64_t checksum      = 0;
    double        alphaCoverage = 0;
};
 
class ISpriteStackModelResolver {
public:
    virtual ~ISpriteStackModelResolver() = default;
    virtual Result<model3d::ModelData*> resolveModel(const std::string& assetId) const = 0;
};
 
class EVENGINE_API_DOMAINS SpriteStackBakeRuntime {
public:
    SpriteStackBakeRuntime();
    ~SpriteStackBakeRuntime();
    // Class-level dllexport instantiates every member, including the implicitly
    // declared copy assignment, whose body instantiates
    // `std::vector<std::unique_ptr<image::ImageData>>::operator=` and fails on the
    // non-copyable element (C2280). The member was already non-copyable in
    // practice; make that explicit instead of relying on the implicit definition.
    SpriteStackBakeRuntime(const SpriteStackBakeRuntime&)            = delete;
    SpriteStackBakeRuntime& operator=(const SpriteStackBakeRuntime&) = delete;
    Result<std::vector<SpriteStackLayerArtifact>> bake(const SpriteStackDocumentTarget& document,
                                                             const ISpriteStackModelResolver* resolver = nullptr);
    Result<spritestack::SpriteStack2D*> publish(graphics::Graphics* graphics, Revision expectedRevision);
    const std::vector<std::unique_ptr<image::ImageData>>& layers() const { return layers_; }
    Revision                                              revision() const { return revision_; }
 
private:
    std::vector<std::unique_ptr<image::ImageData>> layers_;
    std::unique_ptr<spritestack::SpriteStack2D>    stack_;
    SpriteStackAssetValue                          value_;
    Revision                                       revision_ = 0;
};
 
}  // namespace eve::spritestack_editing