Hi Leigh - yes. I’m using APVTS. I’ve tried creating a completely pared down bit of code with just a button and a slider, and I get exactly the same problem. In fact, using beginGesture / setValueNotifyingHost / endGesture doesn’t record automation either, the only thing I’m having any luck with is SliderAttachement.
Here’s my test code:
#pragma once
#include “…/JuceLibraryCode/JuceHeader.h”
#include “PluginProcessor.h”
//==============================================================================
/**
*/
typedef AudioProcessorValueTreeState::SliderAttachment SliderAttachment;
typedef AudioProcessorValueTreeState::ButtonAttachment ButtonAttachment;
class AutomationTestAudioProcessorEditor : public AudioProcessorEditor, Button::Listener
{
public:
AutomationTestAudioProcessorEditor (AutomationTestAudioProcessor&);
~AutomationTestAudioProcessorEditor();
//==============================================================================
void paint (Graphics&) override;
void resized() override;
void buttonClicked(Button* aButton) override;
TextButton myButton;
std::unique_ptr<ButtonAttachment> myButtonAttachment;
Slider mySlider;
std::unique_ptr<SliderAttachment> mySliderAttachment;
private:
// This reference is provided as a quick way for your editor to
// access the processor object that created it.
AutomationTestAudioProcessor& processor;
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AutomationTestAudioProcessorEditor)
};
#include “PluginProcessor.h”
#include “PluginEditor.h”
//==============================================================================
AutomationTestAudioProcessorEditor::AutomationTestAudioProcessorEditor (AutomationTestAudioProcessor& p)
: AudioProcessorEditor (&p), processor §
{
// Make sure that before the constructor has finished, you’ve set the
// editor’s size to whatever you need it to be.
setSize (400, 300);
getLookAndFeel().setColour(TextButton::buttonOnColourId,Colours::darkgreen);
getLookAndFeel().setColour(TextButton::buttonColourId,Colours::transparentBlack);
addAndMakeVisible(myButton);
myButton.setButtonText("Do thing");
myButton.setClickingTogglesState(true);
myButton.addListener(this);
myButtonAttachment.reset(new ButtonAttachment (processor.parameters, "MyButtonStatus", myButton));
addAndMakeVisible(mySlider);
mySliderAttachment.reset(new SliderAttachment (processor.parameters, "MyValue", mySlider));
}
AutomationTestAudioProcessorEditor::~AutomationTestAudioProcessorEditor()
{
}
//==============================================================================
void AutomationTestAudioProcessorEditor::paint (Graphics& g)
{
// (Our component is opaque, so we must completely fill the background with a solid colour)
g.fillAll (getLookAndFeel().findColour (ResizableWindow::backgroundColourId));
g.setColour (Colours::white);
g.setFont (15.0f);
g.drawFittedText ("Hello World!", getLocalBounds(), Justification::centred, 1);
}
void AutomationTestAudioProcessorEditor::resized()
{
// This is generally where you’ll want to lay out the positions of any
// subcomponents in your editor…
auto r = getLocalBounds();
r.removeFromTop(10);
myButton.setBounds(r.removeFromTop(40));
mySlider.setBounds(r.removeFromTop(40));
}
void AutomationTestAudioProcessorEditor::buttonClicked(Button* aButton)
{
processor.randomiseValue();
}
#pragma once
#include “…/JuceLibraryCode/JuceHeader.h”
//==============================================================================
/**
*/
class AutomationTestAudioProcessor : public AudioProcessor
{
public:
//==============================================================================
AutomationTestAudioProcessor();
~AutomationTestAudioProcessor();
//==============================================================================
void prepareToPlay (double sampleRate, int samplesPerBlock) override;
void releaseResources() override;
#ifndef JucePlugin_PreferredChannelConfigurations
bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
#endif
void processBlock (AudioBuffer<float>&, MidiBuffer&) override;
//==============================================================================
AudioProcessorEditor* createEditor() override;
bool hasEditor() const override;
//==============================================================================
const String getName() const override;
bool acceptsMidi() const override;
bool producesMidi() const override;
bool isMidiEffect() const override;
double getTailLengthSeconds() const override;
//==============================================================================
int getNumPrograms() override;
int getCurrentProgram() override;
void setCurrentProgram (int index) override;
const String getProgramName (int index) override;
void changeProgramName (int index, const String& newName) override;
//==============================================================================
void getStateInformation (MemoryBlock& destData) override;
void setStateInformation (const void* data, int sizeInBytes) override;
AudioProcessorValueTreeState parameters;
void randomiseValue();
Random random;
private:
//==============================================================================
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AutomationTestAudioProcessor)
};
//==============================================================================
AutomationTestAudioProcessor::AutomationTestAudioProcessor()
#ifndef JucePlugin_PreferredChannelConfigurations
: AudioProcessor (BusesProperties()
#if ! JucePlugin_IsMidiEffect
#if ! JucePlugin_IsSynth
.withInput (“Input”, AudioChannelSet::stereo(), true)
#endif
.withOutput (“Output”, AudioChannelSet::stereo(), true)
#endif
)
#endif
,parameters (*this, nullptr, Identifier (“AutomationTest”),
{
std::make_unique (“MyValue”,
“MyValue”,
0,
100,
0),
std::make_unique (“MyButtonStatus”,
“MyButtonStatus”,
false)
})
{
}
void AutomationTestAudioProcessor::randomiseValue()
{
auto parameter = parameters.getParameter(“MyValue”);
parameter->beginChangeGesture();
parameter->setValueNotifyingHost(random.nextFloat());
parameter->endChangeGesture();
}
AutomationTestAudioProcessor::~AutomationTestAudioProcessor()
{
}
//==============================================================================
const String AutomationTestAudioProcessor::getName() const
{
return JucePlugin_Name;
}
bool AutomationTestAudioProcessor::acceptsMidi() const
{
#if JucePlugin_WantsMidiInput
return true;
#else
return false;
#endif
}
bool AutomationTestAudioProcessor::producesMidi() const
{
#if JucePlugin_ProducesMidiOutput
return true;
#else
return false;
#endif
}
bool AutomationTestAudioProcessor::isMidiEffect() const
{
#if JucePlugin_IsMidiEffect
return true;
#else
return false;
#endif
}
double AutomationTestAudioProcessor::getTailLengthSeconds() const
{
return 0.0;
}
int AutomationTestAudioProcessor::getNumPrograms()
{
return 1; // NB: some hosts don’t cope very well if you tell them there are 0 programs,
// so this should be at least 1, even if you’re not really implementing programs.
}
int AutomationTestAudioProcessor::getCurrentProgram()
{
return 0;
}
void AutomationTestAudioProcessor::setCurrentProgram (int index)
{
}
const String AutomationTestAudioProcessor::getProgramName (int index)
{
return {};
}
void AutomationTestAudioProcessor::changeProgramName (int index, const String& newName)
{
}
//==============================================================================
void AutomationTestAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
// Use this method as the place to do any pre-playback
// initialisation that you need…
}
void AutomationTestAudioProcessor::releaseResources()
{
// When playback stops, you can use this as an opportunity to free up any
// spare memory, etc.
}
#ifndef JucePlugin_PreferredChannelConfigurations
bool AutomationTestAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
{
#if JucePlugin_IsMidiEffect
ignoreUnused (layouts);
return true;
#else
// This is the place where you check if the layout is supported.
// In this template code we only support mono or stereo.
if (layouts.getMainOutputChannelSet() != AudioChannelSet::mono()
&& layouts.getMainOutputChannelSet() != AudioChannelSet::stereo())
return false;
// This checks if the input layout matches the output layout
#if ! JucePlugin_IsSynth
if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
return false;
#endif
return true;
#endif
}
#endif
void AutomationTestAudioProcessor::processBlock (AudioBuffer& buffer, MidiBuffer& midiMessages)
{
ScopedNoDenormals noDenormals;
auto totalNumInputChannels = getTotalNumInputChannels();
auto totalNumOutputChannels = getTotalNumOutputChannels();
// In case we have more outputs than inputs, this code clears any output
// channels that didn't contain input data, (because these aren't
// guaranteed to be empty - they may contain garbage).
// This is here to avoid people getting screaming feedback
// when they first compile a plugin, but obviously you don't need to keep
// this code if your algorithm always overwrites all the output channels.
for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
buffer.clear (i, 0, buffer.getNumSamples());
// This is the place where you'd normally do the guts of your plugin's
// audio processing...
// Make sure to reset the state if your inner loop is processing
// the samples and the outer loop is handling the channels.
// Alternatively, you can process the samples with the channels
// interleaved by keeping the same state.
for (int channel = 0; channel < totalNumInputChannels; ++channel)
{
auto* channelData = buffer.getWritePointer (channel);
// ..do something to the data...
}
}
//==============================================================================
bool AutomationTestAudioProcessor::hasEditor() const
{
return true; // (change this to false if you choose to not supply an editor)
}
AudioProcessorEditor* AutomationTestAudioProcessor::createEditor()
{
return new AutomationTestAudioProcessorEditor (*this);
}
//==============================================================================
void AutomationTestAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
}
void AutomationTestAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
// You should use this method to restore your parameters from this memory block,
// whose contents will have been created by the getStateInformation() call.
}
//==============================================================================
// This creates new instances of the plugin…
AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
return new AutomationTestAudioProcessor();
}
