AudioTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "audio/editing/AudioEditingTypes.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace eve::audio_editing {
 
class EVENGINE_API_BACKENDS AudioSourceTarget final : public ::eve::editing::EditableTargetState,
                                                      public virtual IEditableTarget,
                                                      public IDomainOperationTarget,
                                                      public IDomainOperationTargetStaging,
                                                      public IPropertyProvider,
                                                      public IEditingSnapshotProvider {
public:
    static CapabilityId editingCapabilityId() { return CapabilityId("eve.editor.target.audio-source"); }
 
    explicit AudioSourceTarget(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 override;
    Result<void> loadSnapshot(const EditorValue& snapshot);
    std::vector<EditorDiagnostic> validate() const;
 
private:
    static PropertySchema sourceSchema();
    static std::map<std::string, EditorValue> defaults();
    bool selectionMatches(const SelectionSnapshot& selection) const;
 
    std::string                        id_;
    std::map<std::string, EditorValue> values_;
};
 
class IAudioSourceRuntimeSink {
public:
    virtual ~IAudioSourceRuntimeSink() = default;
    virtual Result<void> publish(const AudioSourceTarget& candidate) = 0;
};
 
class EVENGINE_API_BACKENDS AudioSourcePublishingTarget final : public IDomainOperationTarget,
                                                                public IDomainOperationTargetStaging {
public:
    AudioSourcePublishingTarget(std::string id, IAudioSourceRuntimeSink* 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(); }
    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;
 
    AudioSourceTarget& authoringTarget() { return document_; }
    const AudioSourceTarget& authoringTarget() const { return document_; }
 
private:
    AudioSourceTarget document_;
    IAudioSourceRuntimeSink* sink_ = nullptr;
    bool staging_ = false;
};
 
struct AudioBusSnapshot {
    ObjectId id;
    ObjectId parent;
    std::string name;
    double volume = 1.0;
    bool mute = false;
    bool solo = false;
    EditorValue effects = EditorValue::Array{};
};
 
class EVENGINE_API_BACKENDS AudioMixerTarget final : public ::eve::editing::EditableTargetState,
                                                     public virtual IEditableTarget,
                                                     public IDomainOperationTarget,
                                                     public IDomainOperationTargetStaging {
public:
    explicit AudioMixerTarget(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;
    Result<AudioBusSnapshot> bus(const ObjectId& id) const;
    std::vector<ObjectId> children(const ObjectId& parent) const;
    Result<DomainOperation> makeCreate(AudioBusSnapshot bus) const;
    Result<DomainOperation> makeDelete(const ObjectId& id) const;
    Result<DomainOperation> makeReplace(AudioBusSnapshot bus) const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    static EditorValue busValue(const AudioBusSnapshot& bus);
    static Result<AudioBusSnapshot> parseBus(const EditorValue& value);
    bool wouldCycle(const ObjectId& id, const ObjectId& parent) const;
 
    std::string                          id_;
    std::map<ObjectId, AudioBusSnapshot> buses_;
};
 
}  // namespace eve::audio_editing
 
namespace eve::audio {
class Source;
}
 
namespace eve::audio_editing {
 
class EVENGINE_API_BACKENDS AudioSourceRuntimeApplier {
public:
    Result<void> apply(const AudioSourceTarget& target, audio::Source* source) const;
};
 
class AudioSourceRuntimeSink final : public IAudioSourceRuntimeSink {
public:
    explicit AudioSourceRuntimeSink(audio::Source* source) : source_(source) {}
    Result<void> publish(const AudioSourceTarget& candidate) override;
 
private:
    audio::Source* source_ = nullptr;
};
 
}  // namespace eve::audio_editing