tracktion_EngineBehaviour.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
struct EditLimits
{
    int maxNumTracks = 400;        
    int maxClipsInTrack = 1500;    
    int maxPluginsOnClip = 5;      
    int maxPluginsOnTrack = 16;    
    int maxNumMasterPlugins = 4;   
};
 
class EngineBehaviour
{
public:
    EngineBehaviour() = default;
    virtual ~EngineBehaviour() = default;
 
    //==============================================================================
    virtual juce::ReferenceCountedObjectPtr<RackType> createPresetRackType (int /*index*/, Edit&)     { return {}; }
 
    virtual Plugin::Ptr createCustomPlugin (PluginCreationInfo)                { return {}; }
 
    virtual std::unique_ptr<juce::PluginDescription> findDescriptionForFileOrID (const juce::String&) { return {}; }
 
    virtual bool isPluginDisabled (const juce::String& /*idString*/)                { return false; }
 
    virtual void setPluginDisabled (const juce::String& /*idString*/, bool /*shouldBeDisabled*/) {}
 
    virtual bool shouldLoadPlugin (ExternalPlugin& p);
 
    virtual void doAdditionalInitialisation (ExternalPlugin&)                       {}
 
    virtual juce::Array<Exportable::ReferencedItem> getReferencedItems (ExternalPlugin&) { return {}; }
 
    virtual void reassignReferencedItem (Clip&, const Exportable::ReferencedItem&, ProjectItemID, double)  {}
 
    virtual juce::Array<Exportable::ReferencedItem> getReferencedItems (Clip&) { return {}; }
 
    virtual void reassignReferencedItem (ExternalPlugin&, const Exportable::ReferencedItem&, ProjectItemID, double)  {}
 
    virtual bool shouldBypassedPluginsBeRemovedFromPlaybackGraph()                { return false; }
 
    virtual bool shouldProcessAuxSendWhenTrackIsMuted (AuxSendPlugin&)            { return true; }
 
    virtual bool areClipSlotsEnabled()                                            { return true; }
 
    virtual bool enableReadAheadForTimeStretchNodes()                             { return false; }
 
    virtual void saveCustomPluginProperties (juce::ValueTree&, juce::AudioPluginInstance&, juce::UndoManager*) {}
 
    virtual bool canScanPluginsOutOfProcess()                                       { return false; }
 
    virtual bool autoInitialiseDeviceManager()                                      { return true; }
 
    virtual bool addSystemAudioIODeviceTypes()                                      { return true; }
 
    // some debate surrounds whether middle-C is C3, C4 or C5. In Tracktion we
    // default this value to 4
    virtual int getMiddleCOctave()                                                  { return 4; }
    virtual void setMiddleCOctave (int /*newOctave*/)                               {}
 
    // Default colour for notes. How this index maps to an actual colour is host dependant.
    // Waveform uses yellow, green, blue, purple, red, auto (based on key)
    virtual int getDefaultNoteColour()                                              { return 0; }
 
    // Notifies the host application that an edit has just been saved
    virtual void editHasBeenSaved (Edit& /*edit*/, juce::File /*path*/)             {}
 
    //==============================================================================
    virtual bool isMidiDriverUsedForIncommingMessageTiming()                        { return true; }
    virtual void setMidiDriverUsedForIncommingMessageTiming (bool)                  {}
 
    virtual bool shouldPlayMidiGuideNotes()                                         { return false; }
 
    virtual bool ignoreBWavTimestamps()                                             { return false; }
 
    virtual int getNumberOfCPUsToUseForAudio()                                      { return juce::jmax (1, juce::SystemStats::getNumCpus()); }
 
    virtual bool shouldProcessMutedTracks()                                         { return false; }
 
    virtual bool muteTrackContentsWhilstRecording()                                 { return false; }
 
    virtual bool areAudioClipsRemappedWhenTempoChanges()                            { return true; }
    virtual void setAudioClipsRemappedWhenTempoChanges (bool)                       {}
    virtual bool areAutoTempoClipsRemappedWhenTempoChanges()                        { return true; }
    virtual void setAutoTempoClipsRemappedWhenTempoChanges (bool)                   {}
    virtual bool areMidiClipsRemappedWhenTempoChanges()                             { return true; }
    virtual void setMidiClipsRemappedWhenTempoChanges (bool)                        {}
    virtual bool arePluginsRemappedWhenTempoChanges()                               { return true; }
    virtual void setPluginsRemappedWhenTempoChanges (bool)                          {}
 
    virtual EditLimits getEditLimits()                                              { return {}; }
 
    virtual bool lengthOfOneBeatDependsOnTimeSignature()                            { return true; }
 
    struct LevelMeterSettings
    {
        int maxPeakAgeMs = 2000;
        float decaySpeed = 48.0f;
    };
 
    virtual LevelMeterSettings getLevelMeterSettings()                              { return {}; }
    virtual void setLevelMeterSettings (LevelMeterSettings)                         {}
 
    // 0 = normal, 1 = high, 2 = realtime
    virtual void setProcessPriority (int /*level*/)                                 {}
 
    virtual bool isDescriptionOfWaveDevicesSupported()                              { return false; }
 
    virtual void describeWaveDevices (std::vector<WaveDeviceDescription>&, juce::AudioIODevice&, bool /*isInput*/) {}
 
    //==============================================================================
    virtual juce::MidiMessageSequence createPlaybackMidiSequence (const MidiList& list, MidiClip& clip, MidiList::TimeBase tb, bool generateMPE)
    {
        return MidiList::createDefaultPlaybackMidiSequence (list, clip, tb, generateMPE);
    }
 
    virtual int getDefaultLoopedSequenceType()                                      { return 0; }
 
    virtual bool autoAddClipEdgeFades()                                             { return false; }
    
    virtual bool interpolateAutomation()                                            { return true; }
 
    struct ClipDefaults
    {
        bool useProxyFile = true;                                           
        ResamplingQuality resamplingQuality = ResamplingQuality::lagrange;  
    };
 
    virtual ClipDefaults getClipDefaults()                                          { return {}; }
 
    virtual void newClipAdded (Clip&, [[ maybe_unused ]] bool fromRecording)        {}
 
    struct ControlSurfaces
    {
        bool mackieMCU = true;
        bool mackieC4 = true;
        bool iconProG2 = true;
        bool tranzport = true;
        bool alphaTrack = true;
        bool remoteSL = true;
        bool remoteSLCompact = true;
        bool automap = true;
    };
 
    virtual ControlSurfaces getDesiredControlSurfaces()                             { return {}; }
 
    virtual ControlSurface* getCustomControlSurfaceForXML (ExternalControllerManager&, const juce::XmlElement&)
    {
        return nullptr;
    }
};
 
}} // namespace tracktion { inline namespace engine