CameraTarget.h

浏览该文件的文档.

#pragma once
 
#include "editing/EditingAuthority.h"
#include "editing/EditingGizmo.h"
#include "editing/EditingProperty.h"
#include "editing/EditableTarget.h"
 
#include <glm/glm.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
namespace eve::camera { class CameraController; }
namespace eve::graphics { class Camera3D; }
 
namespace eve::camera_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 EditorGizmoSnapshot=editing::GizmoSnapshot;using EditorGizmoPrimitive=editing::GizmoPrimitive;using editing::validatePropertyValue;
 
struct CameraRigValue {
    ObjectId id;
    std::string name;
    std::string mode = "follow";
    int priority = 0;
    bool enabled = true;
    glm::vec3 target{0.f};
    glm::vec3 offset{0.f, 2.f, 6.f};
    glm::vec3 lookAhead{0.f};
    glm::vec2 composition{0.f};
    float radius = 10.f;
    float azimuth = 45.f;
    float elevation = 30.f;
    float yaw = 0.f;
    float pitch = 0.f;
    float fov = 60.f;
    float smooth = 6.f;
    float maxSpeed = 0.f;
};
 
struct CameraTimelineKeyValue {
    ObjectId id;
    std::string kind;
    float time = 0.f;
    ObjectId rig;
    float blend = 0.f;
    std::string property;
    float value = 0.f;
    std::string name;
    std::string data;
};
 
class EVENGINE_API_DOMAINS CameraDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                        public virtual IEditableTarget,
                                                        public IDomainOperationTarget,
                                                        public IDomainOperationTargetStaging,
                                                        public IPropertyProvider {
public:
    explicit CameraDocumentTarget(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> makeCreateRig(const CameraRigValue& rig) const;
    Result<DomainOperation> makeDeleteRig(const ObjectId& id) const;
    Result<DomainOperation> makeCreateKey(const CameraTimelineKeyValue& key) const;
    Result<DomainOperation> makeDeleteKey(const ObjectId& id) const;
    const std::vector<CameraRigValue>& rigs() const { return rigs_; }
    std::vector<CameraTimelineKeyValue> timeline() 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 content, std::string property = {}) const;
    std::string                   id_;
    std::vector<CameraRigValue> rigs_; std::vector<CameraTimelineKeyValue> keys_;
};
 
struct CameraPreviewPose { glm::vec3 eye{0.f}; glm::vec3 target{0.f}; float fov = 60.f; ObjectId rig; };
 
class EVENGINE_API_DOMAINS CameraPreview {
public:
    Result<CameraPreviewPose> evaluate(const CameraDocumentTarget& document, float time) const;
    Result<EditorGizmoSnapshot> gizmo(const CameraDocumentTarget& document, float time) const;
};
 
class EVENGINE_API_DOMAINS CameraDocumentRuntime {
public:
    CameraDocumentRuntime();
    ~CameraDocumentRuntime();
    Result<void> publish(const CameraDocumentTarget& document, graphics::Camera3D* camera);
    camera::CameraController* controller() const { return controller_.get(); }
    Revision revision() const { return revision_; }
private:
    std::unique_ptr<camera::CameraController> controller_; Revision revision_ = 0;
};
 
} // namespace eve::camera_editing