Craft.h

Go to the documentation of this file.

// Copyright (c) XJ Music Inc. (https://xjmusic.com) All Rights Reserved.
 
#ifndef XJ_MUSIC_CRAFT_H
#define XJ_MUSIC_CRAFT_H
 
#include <cmath>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include "xjmusic/fabricator/FabricationWrapper.h"
#include "xjmusic/fabricator/Fabricator.h"
#include "xjmusic/fabricator/MarbleBag.h"
#include "xjmusic/fabricator/NotePicker.h"
 
namespace XJ {
 
  class Craft : protected FabricationWrapper {
  protected:
    std::map<std::string, int> deltaIns;
    std::map<std::string, int> deltaOuts;
    std::set<Instrument::Type> finalizeAudioLengthsForInstrumentTypes;
 
  public:
    class InstrumentProvider {
    public:
      virtual ~InstrumentProvider() = default;
 
      virtual std::optional<Instrument> get(const ProgramVoice *voice);
    };
 
    class LambdaInstrumentProvider final : public InstrumentProvider {
    public:
      explicit LambdaInstrumentProvider(std::function<std::optional<Instrument>(ProgramVoice)> func) : func_(
          std::move(func)) {}
 
      std::optional<Instrument> get(const ProgramVoice *voice) override {
        return func_(*voice);
      }
 
    private:
      std::function<std::optional<Instrument>(ProgramVoice)> func_;
    };
 
    class ChoiceIndexProvider {
    public:
      virtual ~ChoiceIndexProvider() = default;
 
      virtual std::string get(const SegmentChoice *choice);
    };
 
    class LambdaChoiceIndexProvider : public ChoiceIndexProvider {
    public:
      explicit LambdaChoiceIndexProvider(std::function<std::string(SegmentChoice)> func) : func_(std::move(func)) {}
 
      std::string get(const SegmentChoice *choice) override {
        return func_(*choice);
      }
 
    private:
      std::function<std::string(SegmentChoice)> func_;
    };
 
    class Section {
    public:
      const SegmentChord *chord;
      float fromPos{};
      float toPos{};
    };
 
    ChoiceIndexProvider choiceIndexProvider = {};
 
    explicit Craft(Fabricator *fabricator);
 
    [[nodiscard]] bool isIntroSegment(const SegmentChoice *choice) const;
 
    [[nodiscard]] bool isOutroSegment(const SegmentChoice *choice) const;
 
    [[nodiscard]] bool isSilentEntireSegment(const SegmentChoice *choice) const;
 
    [[nodiscard]] bool isActiveEntireSegment(const SegmentChoice *choice) const;
 
    void craftNoteEventArrangements(float tempo, const SegmentChoice *choice, bool defaultAtonal);
 
    void precomputeDeltas(
        const std::function<bool(const SegmentChoice *)> &choiceFilter,
        const ChoiceIndexProvider &setChoiceIndexProvider,
        const std::vector<std::string> &layersInCraftOrder,
        const std::set<std::string> &layerPrioritizationSearches,
        const int numLayersIncoming);
 
    static bool inBounds(int floor, int ceiling, float value);
 
    static bool isUnlimitedIn(const SegmentChoice &choice);
 
    static bool isUnlimitedOut(const SegmentChoice &choice);
 
    [[nodiscard]] std::optional<const Program *>
    chooseFreshProgram(Program::Type programType, std::optional<Instrument::Type> voicingType) const;
 
    [[nodiscard]] std::optional<const Instrument *>
    chooseFreshInstrument(Instrument::Type type, const std::set<std::string> &requireEventNames) const;
 
    [[nodiscard]] std::optional<const InstrumentAudio *>
    chooseFreshInstrumentAudio(
        const std::set<Instrument::Type> &types,
        const std::set<Instrument::Mode> &modes,
        const std::set<UUID> &avoidIds,
        const std::set<std::string> &preferredEvents) const;
 
    [[nodiscard]] std::optional<const InstrumentAudio *>
    selectNewChordPartInstrumentAudio(const Instrument *instrument, const Chord &chord) const;
 
    [[nodiscard]] std::set<const InstrumentAudio *> selectGeneralAudioIntensityLayers(const Instrument *instrument) const;
 
  protected:
    [[nodiscard]] std::set<const Program *> programsDirectlyBound(const std::set<const Program *> &programs) const;
 
    static std::set<const Program *> programsPublished(const std::set<const Program *> &programs);
 
    [[nodiscard]] std::set<const Instrument *>
    instrumentsDirectlyBound(const std::set<const Instrument *> &instruments) const;
 
    [[nodiscard]] static std::set<const Instrument *>
    instrumentsPublished(const std::set<const Instrument *> &instruments);
 
    [[nodiscard]] std::set<const InstrumentAudio *>
    audiosDirectlyBound(const std::set<const InstrumentAudio *> &instrumentAudios) const;
 
    [[nodiscard]] std::set<const InstrumentAudio *>
    audiosPublished(const std::set<const InstrumentAudio *> &instrumentAudios) const;
 
    [[nodiscard]] bool computeMute(Instrument::Type instrumentType) const;
 
    void pickInstrumentAudio(
        const SegmentChoiceArrangement *arrangement,
        const InstrumentAudio *audio,
        long startAtSegmentMicros,
        long lengthMicros,
        const std::string& event) const;
 
    [[nodiscard]] std::set<const InstrumentAudio *>
    selectAudioIntensityLayers(std::set<const InstrumentAudio *> audios, const int layers) const;
 
    void craftNoteEvents(
        float tempo,
        const ProgramSequence *sequence,
        const std::set<const ProgramVoice *> &voices,
        LambdaInstrumentProvider instrumentProvider);
 
    void craftChordParts(float tempo, const Instrument *instrument);
 
    void craftChordParts(float tempo, const Instrument *instrument, const SegmentChoice *choice);
 
    void craftEventParts(float tempo, const Instrument *instrument, const Program *program);
 
    int computeDeltaIn(const SegmentChoice *choice);
 
    int computeDeltaOut(const SegmentChoice *choice);
 
  private:
    std::random_device rd;
    std::mt19937 gen{rd()};
 
    void
    craftNoteEventSectionRestartingEachChord(float tempo, const SegmentChoice *choice, NoteRange *range,
                                             bool defaultAtonal) const;
 
    [[nodiscard]] std::vector<Section> computeSections() const;
 
    void craftNoteEventSection(
        float tempo,
        const SegmentChoice *choice,
        float fromPos,
        float maxPos,
        NoteRange *range,
        bool defaultAtonal) const;
 
    float craftPatternEvents(
        float tempo,
        const SegmentChoice *choice,
        const ProgramSequencePattern *pattern,
        float fromPosition,
        float toPosition,
        NoteRange *range,
        bool defaultAtonal) const;
 
    void pickNotesAndInstrumentAudioForEvent(
        const float tempo,
        const Instrument *instrument,
        const SegmentChoice *choice,
        const SegmentChoiceArrangement *arrangement,
        const float fromPosition,
        const float toPosition,
        const ProgramSequencePatternEvent *event,
        NoteRange *range,
        const bool defaultAtonal) const;
 
 
    void finalizeNoteEventCutoffsOfOneShotInstrumentAudioPicks(const SegmentChoice *choice);
 
    [[nodiscard]] float computeVolumeRatioForPickedNote(const SegmentChoice &choice, float segmentPosition) const;
 
    [[nodiscard]] std::set<std::string> pickNotesForEvent(
        Instrument::Type instrumentType,
        const SegmentChoice *choice,
        const ProgramSequencePatternEvent *event,
        const SegmentChord *rawSegmentChord,
        const SegmentChordVoicing *voicing,
        NoteRange *optimalRange) const;
 
    void pickInstrumentAudio(
        const std::string &note,
        const Instrument *instrument,
        const ProgramSequencePatternEvent *event,
        const SegmentChoiceArrangement *segmentChoiceArrangement,
        const long &startAtSegmentMicros,
        const std::optional<long> &lengthMicros,
        const std::optional<UUID> &segmentChordVoicingId,
        const float &volRatio) const;
 
    std::optional<const InstrumentAudio *>
    selectMultiphonicInstrumentAudio(const Instrument *instrument, const ProgramSequencePatternEvent *event,
                                     const std::string &note) const;
 
    [[nodiscard]] std::optional<const InstrumentAudio *>
    selectMonophonicInstrumentAudio(const Instrument *instrument, const ProgramSequencePatternEvent *event) const;
 
    [[nodiscard]] std::optional<const InstrumentAudio *>
    selectChordPartInstrumentAudio(const Instrument *instrument, const Chord &chord) const;
 
    [[nodiscard]] std::optional<const InstrumentAudio *>
    selectNewNoteEventInstrumentAudio(const Instrument *instrument, const ProgramSequencePatternEvent *event) const;
 
    std::optional<const InstrumentAudio *>
    selectNewMultiphonicInstrumentAudio(const Instrument *instrument, std::string note) const;
 
    bool
    instrumentContainsAudioEventsLike(const Instrument &instrument, const std::set<std::string> &requireEvents) const;
  };
 
}// namespace XJ
 
#endif//XJ_MUSIC_CRAFT_H