VirtualGeometryTarget.h

浏览该文件的文档.

#pragma once
 
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
#include "virtualgeometry/Builder.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::virtualgeometry {
struct VirtualGeometryAsset;
}
 
namespace eve::virtualgeometry_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 ObjectId                      = editing::ObjectId;
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 VirtualGeometryImportValue {
    std::string                                      sourceAsset;
    virtualgeometry::VirtualGeometryBuilder::Options builder;
    float                                            previewFov      = 60.f;
    int                                              previewHeight   = 1080;
    float                                            errorPixels     = 1.f;
    float                                            nearDistance    = 1.f;
    float                                            farDistance     = 1000.f;
    int                                              distanceSamples = 32;
};
 
class EVENGINE_API_ORCHESTRATION VirtualGeometryDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                                       public virtual IEditableTarget,
                                                                       public IDomainOperationTarget,
                                                                       public IDomainOperationTargetStaging,
                                                                       public IPropertyProvider {
public:
    explicit VirtualGeometryDocumentTarget(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 VirtualGeometryImportValue& 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_;
    VirtualGeometryImportValue    value_;
};
 
struct VirtualGeometryMeshData {
    std::vector<float>         positions, normals;
    std::vector<std::uint32_t> indices;
};
 
class IVirtualGeometryMeshResolver {
public:
    virtual ~IVirtualGeometryMeshResolver() = default;
    virtual Result<VirtualGeometryMeshData> resolve(const std::string& assetId) const = 0;
};
 
struct VirtualGeometryLodSample {
    float            distance  = 0;
    int              clusters  = 0;
    std::uint64_t    triangles = 0;
    std::vector<int> levelHistogram;
};
 
struct VirtualGeometryBuildArtifact {
    Revision                              sourceRevision  = 0;
    int                                   vertices        = 0;
    std::uint64_t                         sourceTriangles = 0, storedTriangles = 0;
    int                                   clusters = 0, maxLod = 0, roots = 0;
    std::uint64_t                         checksum = 0;
    std::vector<VirtualGeometryLodSample> lodCurve;
};
 
class EVENGINE_API_ORCHESTRATION VirtualGeometryBuildRuntime {
public:
    VirtualGeometryBuildRuntime();
    ~VirtualGeometryBuildRuntime();
    Result<VirtualGeometryBuildArtifact> build(const VirtualGeometryDocumentTarget& document,
                                                     const IVirtualGeometryMeshResolver&  resolver);
    const virtualgeometry::VirtualGeometryAsset* asset() const { return asset_.get(); }
    Revision                                     revision() const { return revision_; }
 
private:
    std::unique_ptr<virtualgeometry::VirtualGeometryAsset> asset_;
    Revision                                               revision_ = 0;
};
 
}  // namespace eve::virtualgeometry_editing