Hd2dTarget.h

浏览该文件的文档.

#pragma once
#include <array>
#include <memory>
#include <string>
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
namespace eve::graphics {
class Graphics;
class Texture;
class Camera3D;
}  // namespace eve::graphics
namespace eve::hd2d {
class Hd2D;
class Sprite3D;
class TileMap3D;
}  // namespace eve::hd2d
namespace eve::hd2d_editing {
using CapabilityId       = editing::CapabilityId;
using DiagnosticSeverity = editing::DiagnosticSeverity;
using DomainOperation    = editing::DomainOperation;
using EditRegion         = editing::EditRegion;
using EditorDiagnostic   = editing::Diagnostic;
using editing::Result;
using EditorStatus                  = editing::Status;
using EditorValue                   = editing::Value;
using IDomainOperationTarget        = editing::IDomainOperationTarget;
using IDomainOperationTargetStaging = editing::IDomainOperationTargetStaging;
using IEditableTarget               = editing::IEditableTarget;
using IPropertyProvider             = editing::IPropertyProvider;
using PropertyDescriptor            = editing::PropertyDescriptor;
using PropertyFlag                  = editing::PropertyFlag;
using PropertyPath                  = editing::PropertyPath;
using PropertyReadResult            = editing::PropertyReadResult;
using PropertyReadState             = editing::PropertyReadState;
using PropertySchema                = editing::PropertySchema;
using PropertySetMode               = editing::PropertySetMode;
using PropertyType                  = editing::PropertyType;
using Revision                      = editing::Revision;
using RuleId                        = editing::RuleId;
using SelectionSnapshot             = editing::SelectionSnapshot;
using TargetDescriptor              = editing::TargetDescriptor;
using TargetId                      = editing::TargetId;
using editing::validatePropertyValue;
struct Hd2dAssetValue {
    std::string          kind = "sprite";
    std::string          sourceAsset;
    int                  columns = 1, rows = 1, frame = 0, animStart = 0, animEnd = 0;
    float                fps   = 12;
    bool                 flipX = false, flipY = false, visible = true;
    std::array<float, 2> size{1, 1};
    std::array<float, 4> tint{1, 1, 1, 1};
    float                sideDepth = 6, heightScale = 1;
    std::array<float, 4> wallUv{0, 0, .05f, .05f};
};
class EVENGINE_API_ORCHESTRATION Hd2dDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                            public virtual IEditableTarget,
                                                            public IDomainOperationTarget,
                                                            public IDomainOperationTargetStaging,
                                                            public IPropertyProvider {
public:
    explicit Hd2dDocumentTarget(std::string id);
    TargetId                                targetId() const override { return TargetId(id_); }
    TargetDescriptor                        describe() const override;
    void*                                   queryCapability(const CapabilityId&) override;
    Result<void>                      applyDomainOperation(const DomainOperation&) override;
    std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    Result<void>                      commitDomainState(std::unique_ptr<IDomainOperationTarget>) override;
    eve::Result<eve::Revision>              currentRevision(const SelectionSnapshot&) const override;
    PropertySchema                          schema(const SelectionSnapshot&) const override;
    PropertyReadResult                      read(const SelectionSnapshot&, const PropertyPath&) const override;
    Result<DomainOperation>           makeSet(const SelectionSnapshot&, const PropertyPath&, const EditorValue&,
                                                    PropertySetMode) const override;
    Result<DomainOperation>           makeReset(const SelectionSnapshot&, const PropertyPath&) const override;
    const Hd2dAssetValue&                   value() const { return value_; }
    std::vector<EditorDiagnostic>           validate() const;
    EditorValue                             snapshotValue() const;
    Result<void>                      loadSnapshot(const EditorValue&);
 
private:
    bool                          matches(const SelectionSnapshot&) const;
    EditorValue                   contentValue() const;
    Result<DomainOperation> replacement(EditorValue, std::string) const;
    std::string                   id_;
    Hd2dAssetValue                value_;
};
struct Hd2dFramePreview {
    int                  frame = 0;
    std::array<float, 4> uv{0, 0, 1, 1};
};
class EVENGINE_API_ORCHESTRATION Hd2dFramePreviewService {
public:
    Result<Hd2dFramePreview> evaluate(const Hd2dDocumentTarget&, float time) const;
};
class IHd2dTextureResolver {
public:
    virtual ~IHd2dTextureResolver()                                            = default;
    virtual Result<graphics::Texture*> texture(const std::string&) const = 0;
};
class EVENGINE_API_ORCHESTRATION Hd2dDocumentRuntime {
public:
    Hd2dDocumentRuntime();
    ~Hd2dDocumentRuntime();
    Result<hd2d::Sprite3D*>  publishSprite(const Hd2dDocumentTarget&, hd2d::Hd2D*, graphics::Graphics*,
                                                 graphics::Camera3D*, const IHd2dTextureResolver&);
    Result<hd2d::TileMap3D*> publishTileMap(const Hd2dDocumentTarget&, hd2d::Hd2D*);
    Revision                       revision() const { return revision_; }
 
private:
    std::unique_ptr<hd2d::Sprite3D>  sprite_;
    std::unique_ptr<hd2d::TileMap3D> tilemap_;
    Revision                         revision_ = 0;
};
}  // namespace eve::hd2d_editing