PhysicsTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "editing/EditableTarget.h"
#include "physics/editing/PhysicsColliderAsset.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace eve::physics_editing {
 
using editing::CapabilityId;
using editing::Diagnostic;
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::Result;
using editing::RuleId;
using editing::SelectionSnapshot;
using editing::Status;
using editing::TargetDescriptor;
using editing::TargetId;
using editing::Value;
 
using EditorStatus     = editing::Status;
using EditorValue      = editing::Value;
using EditorDiagnostic = editing::Diagnostic;
 
using IPhysicsColliderAssetResolver = eve::physics_editing::IPhysicsColliderAssetResolver;
 
class EVENGINE_API_DOMAINS PhysicsColliderTarget final : public ::eve::editing::EditableTargetState,
                                                         public virtual IEditableTarget,
                                                         public IDomainOperationTarget,
                                                         public IDomainOperationTargetStaging,
                                                         public IPropertyProvider {
public:
    explicit PhysicsColliderTarget(std::string id, int dimensions = 3);
 
    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;
    Result<void> loadSnapshot(const EditorValue& snapshot);
    std::vector<EditorDiagnostic> validate() const;
 
private:
    PropertySchema                     colliderSchema() const;
    std::map<std::string, EditorValue> defaults() const;
    Result<void> validateAssignment(const PropertyDescriptor& descriptor, const EditorValue& value) const;
    bool               selectionMatches(const SelectionSnapshot& selection) const;
 
    std::string                        id_;
    int                                dimensions_ = 3;
    std::map<std::string, EditorValue> values_;
};
 
class IPhysicsColliderRuntimeSink {
public:
    virtual ~IPhysicsColliderRuntimeSink() = default;
    virtual Result<void> publish(const PhysicsColliderTarget& candidate) = 0;
};
 
class EVENGINE_API_DOMAINS PhysicsColliderPublishingTarget final : public IDomainOperationTarget,
                                                                   public IDomainOperationTargetStaging {
public:
    PhysicsColliderPublishingTarget(std::string id, int dimensions, IPhysicsColliderRuntimeSink* 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(); }
    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;
    PhysicsColliderTarget& authoringTarget() { return document_; }
    const PhysicsColliderTarget& authoringTarget() const { return document_; }
 
private:
    PhysicsColliderTarget        document_;
    IPhysicsColliderRuntimeSink* sink_    = nullptr;
    bool                         staging_ = false;
};
 
class EVENGINE_API_DOMAINS PhysicsJointTarget final : public ::eve::editing::EditableTargetState,
                                                      public virtual IEditableTarget,
                                                      public IDomainOperationTarget,
                                                      public IDomainOperationTargetStaging,
                                                      public IPropertyProvider {
public:
    explicit PhysicsJointTarget(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;
    std::vector<EditorDiagnostic> validate() const;
 
private:
    static PropertySchema                     jointSchema();
    static std::map<std::string, EditorValue> defaults();
    bool                                      selectionMatches(const SelectionSnapshot& selection) const;
 
    std::string                        id_;
    std::map<std::string, EditorValue> values_;
};
 
}  // namespace eve::physics_editing
 
namespace eve::physics {
class Body;
class Body3D;
class Fixture;
class Shape3D;
}  // namespace eve::physics
 
namespace eve::physics_editing {
 
class PhysicsColliderRuntimeBuilder {
public:
    Result<physics::Fixture*> build2D(const PhysicsColliderTarget& target, physics::Body* body) const;
    Result<physics::Fixture*> build2D(const PhysicsColliderTarget& target, physics::Body* body,
                                            const IPhysicsColliderAssetResolver& assets) const;
    Result<physics::Shape3D*> build3D(const PhysicsColliderTarget& target, physics::Body3D* body) const;
    Result<physics::Shape3D*> build3D(const PhysicsColliderTarget& target, physics::Body3D* body,
                                            const IPhysicsColliderAssetResolver& assets) const;
};
 
class EVENGINE_API_DOMAINS PhysicsCollider3DRuntimeSink final : public IPhysicsColliderRuntimeSink {
public:
    PhysicsCollider3DRuntimeSink(physics::Body3D* body, physics::Shape3D* current = nullptr,
                                 const IPhysicsColliderAssetResolver* assets = nullptr)
        : body_(body), current_(current), assets_(assets) {}
    Result<void> publish(const PhysicsColliderTarget& candidate) override;
    physics::Shape3D* shape() const { return current_; }
 
private:
    physics::Body3D*                     body_    = nullptr;
    physics::Shape3D*                    current_ = nullptr;
    const IPhysicsColliderAssetResolver* assets_  = nullptr;
};
 
class EVENGINE_API_DOMAINS PhysicsCollider2DRuntimeSink final : public IPhysicsColliderRuntimeSink {
public:
    PhysicsCollider2DRuntimeSink(physics::Body* body, physics::Fixture* current = nullptr,
                                 const IPhysicsColliderAssetResolver* assets = nullptr)
        : body_(body), current_(current), assets_(assets) {}
    Result<void> publish(const PhysicsColliderTarget& candidate) override;
    physics::Fixture* fixture() const { return current_; }
 
private:
    physics::Body*                       body_    = nullptr;
    physics::Fixture*                    current_ = nullptr;
    const IPhysicsColliderAssetResolver* assets_  = nullptr;
};
 
}  // namespace eve::physics_editing