versustunez
/
reVeno
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

- save

This commit is contained in:
Maurice Grönwoldt 2020-06-14 21:14:28 +02:00
parent ac22ea5e75
commit a27c62f062
49 changed files with 1171 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
Source/PluginEditor.cpp
View File

@ -3,36 +3,43 @@
#include "Veno/Core/Config.h"
#include "Veno/Utils/Logger.h"
#include "Veno/Fonts/Fonts.h"
#include "Veno/Utils.h"
#define SIDEBAR_WIDTH 300
VenoAudioProcessorEditor::VenoAudioProcessorEditor (VenoAudioProcessor& p)
: AudioProcessorEditor (&p), processor (p)
: AudioProcessorEditor(&p), processor(p)
{
m_id = p.m_id;
Config::getInstance ()->registerEditor (this, m_id);
LookAndFeel::setDefaultLookAndFeel (m_look);
waveform = std::make_unique<SidebarLCD> (m_id);
setSize (600, 400);
addAndMakeVisible (*waveform);
Config::getInstance()->registerEditor(this, m_id);
LookAndFeel::setDefaultLookAndFeel(m_look);
m_sidebar = std::make_unique<Sidebar>(m_id);
setSize(1200 * Config::getInstance()->getScale(), 700 * Config::getInstance()->getScale());
addAndMakeVisible(*m_sidebar);
}
VenoAudioProcessorEditor::~VenoAudioProcessorEditor ()
{
LookAndFeel::setDefaultLookAndFeel (nullptr);
waveform.reset (nullptr);
LookAndFeel::setDefaultLookAndFeel(nullptr);
m_sidebar.reset(nullptr);
delete m_look;
Config::getInstance ()->removeEditor (m_id);
Config::getInstance()->removeEditor(m_id);
}
void VenoAudioProcessorEditor::paint (Graphics& g)
{
g.setFont (*VenoFonts::getNormal ());
g.fillAll (Colour (0, 0, 0));
auto theme = Config::getInstance()->getCurrentTheme();
g.setFont(*VenoFonts::getNormal());
g.fillAll(theme->getColour(ThemeColour::bg_two));
g.setColour(theme->getColour(ThemeColour::bg));
g.fillRect(0, 0, VeNo::Utils::getCalculatedWidth(SIDEBAR_WIDTH), getHeight());
g.setColour(theme->getColour(ThemeColour::accent));
}
void VenoAudioProcessorEditor::resized ()
{
if (waveform != nullptr)
if (m_sidebar != nullptr)
{
waveform->setBounds (0, 0, getWidth (), getHeight ());
m_sidebar->setBounds(0, 0, VeNo::Utils::getCalculatedWidth(SIDEBAR_WIDTH), getHeight());
}
}

6
Source/PluginEditor.h
View File

@ -3,7 +3,7 @@
#include <JuceHeader.h>
#include "PluginProcessor.h"
#include "Veno/GUI/LookAndFeel/LookHandler.h"
#include "Veno/GUI/Components/LCD/SidebarLCD.h"
#include "Veno/GUI/GUIParts/Sidebar/Sidebar.h"
class VenoAudioProcessorEditor : public AudioProcessorEditor
{
@ -15,7 +15,7 @@ public:
private:
VenoAudioProcessor& processor;
std::string m_id = "";
LookAndFeel_V4* m_look = new LookHandler ();
std::unique_ptr<SidebarLCD> waveform;
LookAndFeel_V4* m_look = new LookHandler();
std::unique_ptr<Sidebar> m_sidebar;
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoAudioProcessorEditor)
};

42
Source/PluginProcessor.cpp
View File

@ -13,16 +13,16 @@ VenoAudioProcessor::VenoAudioProcessor ()
#endif
)
#endif*/
: AudioProcessor (BusesProperties ().withInput ("Input", AudioChannelSet::stereo (), true).withOutput ("Output",
AudioChannelSet::stereo (),
true))
: AudioProcessor(BusesProperties().withInput("Input", AudioChannelSet::stereo(), true).withOutput("Output",
AudioChannelSet::stereo(),
true))
{
instance = VenoInstance::createInstance (m_id);
instance = VenoInstance::createInstance(m_id);
}
VenoAudioProcessor::~VenoAudioProcessor ()
{
VenoInstance::deleteInstance (m_id);
VenoInstance::deleteInstance(m_id);
}
const String VenoAudioProcessor::getName () const
@ -88,9 +88,9 @@ void VenoAudioProcessor::changeProgramName (int index, const String& newName)
//==============================================================================
void VenoAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
auto audioConfig = AudioConfig::getInstance ();
audioConfig->setSampleRate (sampleRate);
audioConfig->initWaveTables ();
auto audioConfig = AudioConfig::getInstance();
audioConfig->setSampleRate(sampleRate);
audioConfig->initWaveTables();
}
void VenoAudioProcessor::releaseResources ()
@ -105,8 +105,8 @@ bool VenoAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) con
ignoreUnused (layouts);
return true;
#else
if (layouts.getMainOutputChannelSet () != AudioChannelSet::mono ()
&& layouts.getMainOutputChannelSet () != AudioChannelSet::stereo ())
if (layouts.getMainOutputChannelSet() != AudioChannelSet::mono()
&& layouts.getMainOutputChannelSet() != AudioChannelSet::stereo())
return false;
#if !JucePlugin_IsSynth
if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
@ -121,23 +121,23 @@ bool VenoAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) con
void VenoAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer& midiMessages)
{
ScopedNoDenormals noDenormals;
instance->matrix.updateSlots ();
instance->audioBuffer->reset (buffer.getNumSamples ());
int numChannels = buffer.getNumChannels ();
instance->matrix.updateSlots();
instance->audioBuffer->reset(buffer.getNumSamples());
int numChannels = buffer.getNumChannels();
for (int i = 0; i < numChannels; ++i)
{
auto c = buffer.getReadPointer (i);
for (int j = 0; j < buffer.getNumSamples (); ++j)
auto c = buffer.getReadPointer(i);
for (int j = 0; j < buffer.getNumSamples(); ++j)
{
instance->fft.pushNextSampleIntoFifo (c[j]);
instance->audioBuffer->addMonoSample (c[j], j);
instance->fft.pushNextSampleIntoFifo(c[j]);
instance->audioBuffer->addMonoSample(c[j], j);
if (i == 0)
{
instance->audioBuffer->addLeftSample (c[j], j);
instance->audioBuffer->addLeftSample(c[j], j);
}
if (i == 1 || numChannels == 1)
{
instance->audioBuffer->addRightSample (c[j], j);
instance->audioBuffer->addRightSample(c[j], j);
}
}
}
@ -151,7 +151,7 @@ bool VenoAudioProcessor::hasEditor () const
AudioProcessorEditor* VenoAudioProcessor::createEditor ()
{
return new VenoAudioProcessorEditor (*this);
return new VenoAudioProcessorEditor(*this);
}
//==============================================================================
@ -165,5 +165,5 @@ void VenoAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
AudioProcessor* JUCE_CALLTYPE createPluginFilter ()
{
return new VenoAudioProcessor ();
return new VenoAudioProcessor();
}

66
Source/PluginProcessor.h
View File

@ -3,57 +3,35 @@
#include <JuceHeader.h>
#include "Veno/VenoInstance.h"
class VenoAudioProcessor : public AudioProcessor {
class VenoAudioProcessor : public AudioProcessor
{
public:
//==============================================================================
VenoAudioProcessor();
~VenoAudioProcessor();
void prepareToPlay(double sampleRate, int samplesPerBlock) override;
void releaseResources() override;
VenoAudioProcessor ();
~VenoAudioProcessor ();
void prepareToPlay (double sampleRate, int samplesPerBlock) override;
void releaseResources () override;
#ifndef JucePlugin_PreferredChannelConfigurations
bool isBusesLayoutSupported(const BusesLayout &layouts) const override;
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;
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;
// Variable to communicate with the GUI and the Processor
std::string m_id = Uuid().toString().toStdString();
std::shared_ptr<VenoInstance> instance;
private:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoAudioProcessor)
};

20
Source/Veno/Audio/Engine/VenoMatrix.cpp
View File

@ -4,11 +4,11 @@
#include "VenoMatrix.h"
VenoMatrix::VenoMatrix (const std::string& processId) : m_processId (processId)
VenoMatrix::VenoMatrix (const std::string& processId) : m_processId(processId)
{
for (auto& m_slot : m_slots)
{
m_slot = new VenoMatrixSlot ();
m_slot = new VenoMatrixSlot();
}
}
@ -27,22 +27,22 @@ VenoMatrixSlot* VenoMatrix::getSlotById (int id)
void VenoMatrix::removeModulateValue (const std::string& name)
{
m_modulationValues.erase (name);
m_modulationValues.erase(name);
}
void VenoMatrix::removeModulator (const std::string& name)
{
m_modulators.erase (name);
m_modulators.erase(name);
}
void VenoMatrix::addModulateValue (const std::string& name, ModulateValue* modulateValue)
{
m_modulationValues.emplace (std::pair<const std::string&, ModulateValue*> (name, modulateValue));
m_modulationValues.emplace(std::pair<const std::string&, ModulateValue*>(name, modulateValue));
}
void VenoMatrix::addModulator (const std::string& name, Modulator* modulator)
{
m_modulators.emplace (std::pair<const std::string&, Modulator*> (name, modulator));
m_modulators.emplace(std::pair<const std::string&, Modulator*>(name, modulator));
}
void VenoMatrix::updateSlots ()
@ -53,26 +53,26 @@ void VenoMatrix::updateSlots ()
{
continue;
}
if (m_modulators.find (m_slot->sourceName) != m_modulators.end ())
if (m_modulators.find(m_slot->sourceName) != m_modulators.end())
{
auto modulator = m_modulators[m_slot->sourceName];
if (modulator == nullptr)
{
continue;
}
modulator->update ();
modulator->update();
for (auto& value : m_slot->targets)
{
if (value.name != "none")
{
if (m_modulationValues.find (value.name) != m_modulationValues.end ())
if (m_modulationValues.find(value.name) != m_modulationValues.end())
{
auto modValue = m_modulationValues[value.name];
if (modValue == nullptr)
{
continue;
}
modValue->addValue (modulator->getValue () * value.amount);
modValue->addValue(modulator->getValue() * value.amount);
}
}
}

2
Source/Veno/Audio/Synth/SynthInstance.cpp
View File

@ -6,6 +6,6 @@
#include <utility>
SynthInstance::SynthInstance (std::string processId)
: m_processId (std::move (processId))
: m_processId(std::move(processId))
{
}

22
Source/Veno/Audio/VenoBuffer.cpp
View File

@ -12,18 +12,18 @@ VenoBuffer::VenoBuffer ()
VenoBuffer::~VenoBuffer ()
{
buffer.clear ();
right.clear ();
left.clear ();
buffer.clear();
right.clear();
left.clear();
}
void VenoBuffer::reset (int size)
{
if (size != buffer.size ())
if (size != buffer.size())
{
buffer.resize (size);
right.resize (size);
left.resize (size);
buffer.resize(size);
right.resize(size);
left.resize(size);
}
// reset to 0 dc :D
for (int i = 0; i < size; ++i)
@ -54,11 +54,11 @@ void VenoBuffer::addRightSample (float value, int index)
void VenoBuffer::calcPeak ()
{
for (int i = 0; i < buffer.size (); ++i)
for (int i = 0; i < buffer.size(); ++i)
{
auto l = std::abs (left[i]);
auto r = std::abs (right[i]);
auto m = std::abs (buffer[i]);
auto l = std::abs(left[i]);
auto r = std::abs(right[i]);
auto m = std::abs(buffer[i]);
if (m > monoPeak)
{
monoPeak = m;

6
Source/Veno/Audio/WaveTable/SawWaves.cpp
View File

@ -12,7 +12,7 @@ void generateSaw (WaveTableGroup* group)
{
return;
}
int tableLen = findTableLen ();
int tableLen = findTableLen();
int idx;
auto* freqWaveRe = new double[tableLen];
auto* freqWaveIm = new double[tableLen];
@ -26,6 +26,6 @@ void generateSaw (WaveTableGroup* group)
freqWaveRe[idx] = 1.0 / idx; // sawtooth spectrum
freqWaveRe[tableLen - idx] = -freqWaveRe[idx]; // mirror
}
fillTables (group, freqWaveRe, freqWaveIm, tableLen);
VeNo::Logger::infoDebugMessage ("Generated clean Saw Wave");
fillTables(group, freqWaveRe, freqWaveIm, tableLen);
VeNo::Logger::infoDebugMessage("Generated clean Saw Wave");
}

20
Source/Veno/Audio/WaveTable/TableHelper.cpp
View File

@ -51,8 +51,8 @@ void fft (int N, double* ar, double* ai)
LE *= 2; // (LE = 2^L)
Ur = 1.0;
Ui = 0.;
Wr = std::cos (M_PI / (float) LE1);
Wi = -std::sin (M_PI / (float) LE1); // Cooley, Lewis, and Welch have "+" here
Wr = std::cos(M_PI / (float) LE1);
Wi = -std::sin(M_PI / (float) LE1); // Cooley, Lewis, and Welch have "+" here
for (j = 1; j <= LE1; j++)
{
for (i = j; i <= N; i += LE)
@ -74,14 +74,14 @@ void fft (int N, double* ar, double* ai)
float makeWaveTable (WaveTableGroup* group, int len, double* ar, double* ai, double scale, double topFreq)
{
fft (len, ar, ai);
fft(len, ar, ai);
if (scale == 0.0)
{
// calc normal
double max = 0;
for (int idx = 0; idx < len; idx++)
{
double temp = fabs (ai[idx]);
double temp = fabs(ai[idx]);
if (max < temp)
max = temp;
}
@ -94,7 +94,7 @@ float makeWaveTable (WaveTableGroup* group, int len, double* ar, double* ai, dou
wave[idx] = ai[idx] * scale;
if (group->m_numWaveTables < WaveTableGroup::numWaveTableSlots)
{
auto table = group->m_WaveTables[group->m_numWaveTables] = new WaveTableObject ();
auto table = group->m_WaveTables[group->m_numWaveTables] = new WaveTableObject();
float* waveTable = group->m_WaveTables[group->m_numWaveTables]->m_waveTable = new float[len + 1];
table->m_waveTableLen = len;
table->m_topFreq = topFreq;
@ -121,7 +121,7 @@ int fillTables (WaveTableGroup* group, double* freqWaveRe, double* freqWaveIm, i
freqWaveRe[numSamples >> 1] = freqWaveIm[numSamples >> 1] = 0.0;
int maxHarmonic = numSamples >> 1;
const double minVal = 0.000001; // -120 dB
while ((fabs (freqWaveRe[maxHarmonic]) + fabs (freqWaveIm[maxHarmonic]) < minVal) && maxHarmonic) --maxHarmonic;
while ((fabs(freqWaveRe[maxHarmonic]) + fabs(freqWaveIm[maxHarmonic]) < minVal) && maxHarmonic) --maxHarmonic;
double topFreq = 2.0 / 3.0 / maxHarmonic;
double* ar = new double[numSamples];
double* ai = new double[numSamples];
@ -141,7 +141,7 @@ int fillTables (WaveTableGroup* group, double* freqWaveRe, double* freqWaveIm, i
}
// make the wavetable
scale = makeWaveTable (group, numSamples, ar, ai, scale, topFreq);
scale = makeWaveTable(group, numSamples, ar, ai, scale, topFreq);
numTables++;
// prepare for next table
@ -153,11 +153,11 @@ int fillTables (WaveTableGroup* group, double* freqWaveRe, double* freqWaveIm, i
float getNextRand ()
{
return std::rand () / double (RAND_MAX);
return std::rand() / double(RAND_MAX);
}
int findTableLen ()
{
int maxHarms = AudioConfig::getInstance ()->getSampleRate () / (5.0 * 20) + 0.5;
return VeNo::Utils::nextPowerOfTwo (maxHarms) * 2;
int maxHarms = AudioConfig::getInstance()->getSampleRate() / (5.0 * 20) + 0.5;
return VeNo::Utils::nextPowerOfTwo(maxHarms) * 2;
}

28
Source/Veno/Audio/WaveTable/WaveTableGenerator.cpp
View File

@ -9,25 +9,25 @@
void WaveTableGenerator::init ()
{
//if the sampleRate changed... the WaveTables are not harmonic Save anymore and are needed to rebuild... pls stay save later!
if (AudioConfig::getInstance ()->isNeedToReInit ())
if (AudioConfig::getInstance()->isNeedToReInit())
{
cleanTables ();
AudioConfig::getInstance ()->setNeedToReInit (false);
cleanTables();
AudioConfig::getInstance()->setNeedToReInit(false);
}
if (m_isInit)
{
return;
}
m_waveTables[WaveForms::SAW] = new WaveTableGroup ();
m_waveTables[WaveForms::SINE] = new WaveTableGroup ();
m_waveTables[WaveForms::SQUARE] = new WaveTableGroup ();
m_waveTables[WaveForms::TRIANGLE] = new WaveTableGroup ();
m_waveTables[WaveForms::wSaw] = new WaveTableGroup ();
m_waveTables[WaveForms::wSQUARE] = new WaveTableGroup ();
m_waveTables[WaveForms::SYNTHONE] = new WaveTableGroup ();
m_waveTables[WaveForms::SYNTHTWO] = new WaveTableGroup ();
m_waveTables[WaveForms::VENOX] = new WaveTableGroup ();
generateSaw (m_waveTables[WaveForms::SAW]);
m_waveTables[WaveForms::SAW] = new WaveTableGroup();
m_waveTables[WaveForms::SINE] = new WaveTableGroup();
m_waveTables[WaveForms::SQUARE] = new WaveTableGroup();
m_waveTables[WaveForms::TRIANGLE] = new WaveTableGroup();
m_waveTables[WaveForms::wSaw] = new WaveTableGroup();
m_waveTables[WaveForms::wSQUARE] = new WaveTableGroup();
m_waveTables[WaveForms::SYNTHONE] = new WaveTableGroup();
m_waveTables[WaveForms::SYNTHTWO] = new WaveTableGroup();
m_waveTables[WaveForms::VENOX] = new WaveTableGroup();
generateSaw(m_waveTables[WaveForms::SAW]);
m_isInit = true;
}
@ -35,7 +35,7 @@ WaveTableGroup* WaveTableGenerator::getGroup (int id)
{
if (!m_isInit)
{
init ();
init();
}
if (id < 40)
{

6
Source/Veno/Core/AudioConfig.cpp
View File

@ -43,16 +43,16 @@ void AudioConfig::setNeedToReInit (bool _needToReInit)
std::shared_ptr<AudioConfig> AudioConfig::getInstance ()
{
if (AudioConfig::m_instance == nullptr)
AudioConfig::m_instance = std::make_shared<AudioConfig> ();
AudioConfig::m_instance = std::make_shared<AudioConfig>();
return m_instance;
}
void AudioConfig::initWaveTables ()
{
WaveTableGenerator::getInstance ().init ();
WaveTableGenerator::getInstance().init();
}
AudioConfig::~AudioConfig ()
{
WaveTableGenerator::getInstance ().cleanTables ();
WaveTableGenerator::getInstance().cleanTables();
}

77
Source/Veno/Core/Config.cpp
View File

@ -4,23 +4,26 @@
#include "Config.h"
#include "../Fonts/Fonts.h"
#include "../GUI/GUIParts/Sidebar/VenoLogo.h"
#include "../Utils.h"
std::shared_ptr<Config> Config::m_instance = nullptr;
Config::Config ()
{
// i want to load the m_config file here...
initConfig ();
m_theme = std::make_shared<Theme> (m_config);
m_theme->init ();
m_fps = m_config->getIntValue ("waveform_fps", 60);
initConfig();
m_theme = std::make_shared<Theme>(m_config);
m_theme->init();
m_fps = m_config->getIntValue("waveform_fps", 60);
startTimer(5000);
}
void Config::saveAll ()
{
if (m_config != nullptr)
{
m_config->saveIfNeeded ();
m_config->saveIfNeeded();
}
}
@ -39,7 +42,8 @@ void Config::initConfig ()
options.applicationName = "config";
options.folderName = "veno";
options.filenameSuffix = "xml";
m_config = std::make_unique<PropertiesFile> (options);
m_config = std::make_unique<PropertiesFile>(options);
m_scale = (float) m_config->getDoubleValue("scale", 1.0);
}
std::shared_ptr<Theme> Config::getCurrentTheme ()
@ -47,24 +51,29 @@ std::shared_ptr<Theme> Config::getCurrentTheme ()
return m_theme;
}
double Config::getScale ()
double Config::getScale () const
{
return 1;
return m_scale;
}
void Config::setColourForIndex (Colour* colour, ThemeColour index)
{
if (m_theme)
{
m_theme->setColour (index, colour);
m_theme->setColour(index, colour);
}
}
Config::~Config ()
{
m_config->save ();
m_theme.reset ();
m_config.reset ();
m_config->save();
m_config->setNeedsToBeSaved(false);
m_theme.reset();
m_config.reset();
m_lookHandler.reset();
stopTimer();
VenoFonts::destroyAll();
VenoLogo::deleteInstance();
}
//LEAK DETECTOR FIX!
@ -75,10 +84,9 @@ void Config::registerEditor (AudioProcessorEditor* editor, const std::string& na
void Config::removeEditor (const std::string& name)
{
m_editors.erase (name);
if (m_editors.empty ())
m_editors.erase(name);
if (m_editors.empty())
{
VenoFonts::destroyAll ();
m_instance = nullptr;
}
}
@ -86,13 +94,13 @@ void Config::removeEditor (const std::string& name)
//for LCD :P let's be a bit funny xD
int Config::getEditorCount ()
{
return m_editors.size ();
return m_editors.size();
}
std::shared_ptr<Config> Config::getInstance ()
{
if (m_instance == nullptr)
m_instance = std::make_shared<Config> ();
m_instance = std::make_shared<Config>();
return m_instance;
}
@ -100,3 +108,38 @@ int Config::getFps () const
{
return m_fps;
}
void Config::setScale (float value)
{
value = VeNo::Utils::clamp(value, 0.5f, 2.5f);
m_scale = value;
m_config->setValue("scale", m_scale);
m_config->setNeedsToBeSaved(true);
for (auto& editor : m_editors)
{
editor.second->setSize(1200 * m_scale, 700 * m_scale);
}
}
void Config::timerCallback ()
{
m_config->saveIfNeeded();
}
void Config::repaintAll ()
{
for (auto& editor : m_editors)
{
if (editor.second->isShowing())
{
editor.second->repaint();
}
}
}
void Config::setFps (float value)
{
m_fps = VeNo::Utils::clamp(value, 15, 90);
m_config->setValue("waveform_fps", m_fps);
m_config->setNeedsToBeSaved(true);
}

12
Source/Veno/Core/Config.h
View File

@ -10,7 +10,7 @@
#include "../GUI/Theme/Theme.h"
#include <memory>
class Config
class Config : public Timer
{
private:
std::shared_ptr<PropertiesFile> m_config = nullptr;
@ -18,14 +18,16 @@ private:
static std::shared_ptr<Config> m_instance;
int m_currentLook = 0; //nah move the bitch logic from current to next
std::unordered_map<std::string, AudioProcessorEditor*> m_editors;
int m_fps = 60;
std::shared_ptr<LookHandler> m_lookHandler;
public:
int m_fps = 60;
float m_scale = 1.0f;
static std::shared_ptr<Config> getInstance ();
void saveAll ();
int getCurrentLook ();
void setColourForIndex (Colour* colour, ThemeColour index);
std::shared_ptr<Theme> getCurrentTheme ();
double getScale ();
double getScale () const;
// can be public but doesnt need!
Config ();
~Config ();
@ -33,6 +35,10 @@ public:
void removeEditor (const std::string& name);
int getEditorCount ();
int getFps () const;
void setScale(float value);
void setFps(float value);
void timerCallback () override;
void repaintAll();
protected:
void initConfig ();
};

16
Source/Veno/Core/VeNoState.cpp Normal file
View File

@ -0,0 +1,16 @@
//
// Created by versustune on 14.06.20.
//
#include "VeNoState.h"
VeNoState::VeNoState (std::string pid)
{
m_pid = pid;
}
VeNoState::~VeNoState ()
{
delete configScreen;
configScreen = nullptr;
}

20
Source/Veno/Core/VeNoState.h Normal file
View File

@ -0,0 +1,20 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_VENOSTATE_H
#define VENO_VENOSTATE_H
#include <string>
#include "../GUI/GUIParts/ConfigScreen/VenoConfigScreen.h"
class VeNoState
{
protected:
std::string m_pid = "";
public:
VeNoState(std::string pid);
~VeNoState();
VenoConfigScreen* configScreen = nullptr;
};
#endif //VENO_VENOSTATE_H

16
Source/Veno/Fonts/Fonts.cpp
View File

@ -4,23 +4,23 @@
#include "Fonts.h"
VenoFonts* VenoFonts::instance = new VenoFonts ();
VenoFonts* VenoFonts::instance = new VenoFonts();
Font* VenoFonts::getNormal ()
{
return getInstance ()->arvo;
return getInstance()->arvo;
}
Font* VenoFonts::getLCD ()
{
return getInstance ()->lcdFont;
return getInstance()->lcdFont;
}
VenoFonts* VenoFonts::getInstance ()
{
if (instance == nullptr)
{
instance = new VenoFonts ();
instance = new VenoFonts();
}
return instance;
}
@ -33,10 +33,10 @@ void VenoFonts::destroyAll ()
VenoFonts::VenoFonts ()
{
arvo = new Font (Typeface::createSystemTypefaceFor (BinaryData::arvo_ttf,
BinaryData::arvo_ttfSize));
lcdFont = new Font (Typeface::createSystemTypefaceFor (BinaryData::lcd_ttf,
BinaryData::lcd_ttfSize));
arvo = new Font(Typeface::createSystemTypefaceFor(BinaryData::arvo_ttf,
BinaryData::arvo_ttfSize));
lcdFont = new Font(Typeface::createSystemTypefaceFor(BinaryData::lcd_ttf,
BinaryData::lcd_ttfSize));
}
VenoFonts::~VenoFonts ()

23
Source/Veno/GUI/Components/BaseComponent.cpp
View File

@ -3,6 +3,7 @@
//
#include "BaseComponent.h"
#include "../../Utils.h"
#include "../../Fonts/Fonts.h"
#include <utility>
@ -13,40 +14,42 @@ BaseComponent::BaseComponent (const std::string& processId)
BaseComponent::~BaseComponent ()
{
m_label.reset ();
m_label.reset();
}
void BaseComponent::addLabel (const std::string& label_text, LabelPosition labelPosition)
{
m_enableLabel = true;
m_label = std::make_shared<LabelComponent> (this, label_text);
m_label->setPosition (labelPosition);
m_label = std::make_shared<LabelComponent>(this, label_text);
m_label->setPosition(labelPosition);
addAndMakeVisible(*m_label);
}
void BaseComponent::resized ()
{
if (m_enableLabel && m_label != nullptr)
{
LabelPosition position = m_label->getLabelPosition ();
LabelPosition position = m_label->getLabelPosition();
if (position == LabelPosition::TOP)
{
m_label->setBounds (0, 0, getWidth (), 15);
m_label->setBounds(0, 0, getWidth(), VeNo::Utils::getCalculatedHeight(15));
}
else if (position == LabelPosition::BOTTOM)
{
m_label->setBounds (0, getHeight () - 20, getWidth (), 15);
auto height = VeNo::Utils::getCalculatedHeight(15);
m_label->setBounds(0, getHeight() - height, getWidth(), height);
}
}
}
void BaseComponent::paint (Graphics& g)
{
g.setFont (*VenoFonts::getNormal ());
g.setFont(*VenoFonts::getNormal());
}
void BaseComponent::setParameter (std::string name, std::string group)
{
m_name = std::move (name);
m_group = std::move (group);
setName (m_name);
m_name = std::move(name);
m_group = std::move(group);
setName(m_name);
}

2
Source/Veno/GUI/Components/BaseComponent.h
View File

@ -19,7 +19,6 @@ private:
std::string m_group;
std::string m_name;
bool m_enableLabel = false;
std::shared_ptr<LabelComponent> m_label;
public:
explicit BaseComponent (const std::string& processId);
~BaseComponent () override;
@ -29,5 +28,6 @@ public:
void paint (Graphics& g) override;
protected:
std::string m_processId;
std::shared_ptr<LabelComponent> m_label;
};
#endif //VENO_BASECOMPONENT_H

65
Source/Veno/GUI/Components/Config/VeNoColour.cpp Normal file
View File

@ -0,0 +1,65 @@
//
// Created by versustune on 14.06.20.
//
#include "VeNoColour.h"
#include <utility>
#include "../../../Core/Config.h"
#include "../../../Utils.h"
using ColourOption = ColourSelector::ColourSelectorOptions;
VeNoColour::~VeNoColour ()
{
BaseComponent::m_label.reset();
m_selector.reset();
}
VeNoColour::VeNoColour (const std::string& processId, ThemeColour index)
: BaseComponent(processId)
{
m_index = index;
m_selector = std::make_unique<ColourSelector>(
ColourOption::showColourAtTop|ColourOption::editableColour|ColourOption::showColourspace);
m_selector->setCurrentColour(Config::getInstance()->getCurrentTheme()->getColour(index),
NotificationType::dontSendNotification);
m_selector->addChangeListener(this);
m_selector->setOpaque(false);
addAndMakeVisible(*m_selector);
}
void VeNoColour::setName (std::string name)
{
m_name = std::move(name);
if (BaseComponent::m_label == nullptr)
{
BaseComponent::addLabel(m_name, LabelPosition::TOP);
}
}
void VeNoColour::changeListenerCallback (ChangeBroadcaster* source)
{
auto selector = m_selector->getCurrentColour();
auto* colour = new Colour(selector.getRed(), selector.getGreen(), selector.getBlue(),
1.0f);
Config::getInstance()->getCurrentTheme()->setColour(m_index, colour);
Config::getInstance()->repaintAll();
}
void VeNoColour::resized ()
{
auto h = VeNo::Utils::getCalculatedHeight(30);
if (BaseComponent::m_label != nullptr)
{
BaseComponent::m_label->setBounds(0, 0, getWidth(), h);
}
if (m_selector != nullptr)
{
m_selector->setBounds(0, h, getWidth(), getHeight() - h);
}
}
void VeNoColour::paint (Graphics& g)
{
g.setColour(Colours::white);
BaseComponent::paint(g);
}

27
Source/Veno/GUI/Components/Config/VeNoColour.h Normal file
View File

@ -0,0 +1,27 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_VENOCOLOUR_H
#define VENO_VENOCOLOUR_H
#include "JuceHeader.h"
#include "../BaseComponent.h"
#include "../../Theme/Theme.h"
class VeNoColour : public BaseComponent, ChangeListener
{
private:
ThemeColour m_index;
std::unique_ptr<ColourSelector> m_selector;
std::string m_name;
public:
explicit VeNoColour (const std::string& processId, ThemeColour index);
~VeNoColour () override;
void setName(std::string name);
void resized () override;
void paint (Graphics& g) override;
private:
void changeListenerCallback (ChangeBroadcaster* source) override;
};
#endif //VENO_VENOCOLOUR_H

34
Source/Veno/GUI/Components/Config/VenoConfigButton.cpp Normal file
View File

@ -0,0 +1,34 @@
//
// Created by versustune on 14.06.20.
//
#include "VenoConfigButton.h"
#include "../../../Core/Config.h"
#include "../../../Utils.h"
#include "../../../VenoInstance.h"
#include "../../../Utils/Logger.h"
VenoConfigButton::VenoConfigButton (const std::string& processId) : BaseComponent(processId)
{
setMouseCursor(MouseCursor::PointingHandCursor);
}
void VenoConfigButton::paint (Graphics& g)
{
auto theme = Config::getInstance()->getCurrentTheme();
VeNo::Utils::setFontSize(16.0f, g);
g.setColour(theme->getColour(ThemeColour::accent));
g.drawRect(0, 0, getWidth(), getHeight());
g.drawFittedText("Config", 0, 0, getWidth(), getHeight(), Justification::centred, 1, 1);
}
void VenoConfigButton::mouseDown (const MouseEvent& event)
{
// open Window on click :)
auto state = VenoInstance::getInstance(m_processId)->state;
if (state->configScreen != nullptr)
{
return;
}
state->configScreen = new VenoConfigScreen(m_processId);
}

21
Source/Veno/GUI/Components/Config/VenoConfigButton.h Normal file
View File

@ -0,0 +1,21 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_VENOCONFIGBUTTON_H
#define VENO_VENOCONFIGBUTTON_H
#include "JuceHeader.h"
#include "../BaseComponent.h"
class VenoConfigButton : public BaseComponent
{
public:
VenoConfigButton (const std::string& processId);
~VenoConfigButton() = default;
void paint (Graphics& g) override;
void mouseDown (const MouseEvent& event) override;
private:
};
#endif //VENO_VENOCONFIGBUTTON_H

84
Source/Veno/GUI/Components/Config/VenoPreColours.cpp Normal file
View File

@ -0,0 +1,84 @@
//
// Created by versustune on 14.06.20.
//
#include "VenoPreColours.h"
#include "../../../Core/Config.h"
VenoPreColours::VenoPreColours (const std::string& processId) : BaseComponent(processId)
{
initSliders();
initButtons();
}
VenoPreColours::~VenoPreColours ()
{
m_scaleSlider.reset();
m_fpsSlider.reset();
for (int i = 0; i < 4; ++i)
{
m_pre[i].reset();
}
}
void VenoPreColours::initSliders ()
{
m_fpsSlider = std::make_shared<Slider>();
m_fpsSlider->setRange(15, 90, 1);
m_fpsSlider->setValue(Config::getInstance()->getFps());
m_fpsSlider->setSliderStyle(Slider::SliderStyle::LinearHorizontal);
m_fpsSlider->setTooltip("FPS");
m_scaleSlider = std::make_shared<Slider>();
m_scaleSlider->setRange(0.5f, 2.5f, 0.1);
m_scaleSlider->setValue(Config::getInstance()->getScale());
m_scaleSlider->setSliderStyle(Slider::SliderStyle::LinearHorizontal);
m_scaleSlider->setTooltip("Scale");
m_scaleSlider->addListener(this);
m_fpsSlider->addListener(this);
addAndMakeVisible(*m_fpsSlider);
addAndMakeVisible(*m_scaleSlider);
}
void VenoPreColours::sliderValueChanged (Slider* slider)
{
if (slider == m_fpsSlider.get())
{
Config::getInstance()->setFps(slider->getValue());
}
if (slider == m_scaleSlider.get())
{
Config::getInstance()->setScale(slider->getValue());
}
}
void VenoPreColours::initButtons ()
{
//4
m_pre.resize(4);
for (int i = 0; i < 4; ++i)
{
m_pre[i] = std::make_unique<TextButton>(m_names[i]);
m_pre[i]->addListener(this);
addAndMakeVisible(m_pre[i].get());
}
}
void VenoPreColours::buttonClicked (Button* button)
{
auto text = button->getButtonText().toStdString();
Config::getInstance()->getCurrentTheme()->setDefault(text);
}
void VenoPreColours::resized ()
{
auto bounds = Rectangle<int>();
bounds.setBounds(0,0,getWidth(), getHeight()-100);
auto bWidth = (getWidth()-80) / 4;
for (int i = 0; i < 4 ; ++i)
{
m_pre[i]->setBounds((bWidth * i) + 40, 110, bWidth, 50);
}
// set slider and button position
m_fpsSlider->setBounds(20, 0, getWidth()-40, 50);
m_scaleSlider->setBounds(20, 50, getWidth()-40, 50);
}

30
Source/Veno/GUI/Components/Config/VenoPreColours.h Normal file
View File

@ -0,0 +1,30 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_VENOPRECOLOURS_H
#define VENO_VENOPRECOLOURS_H
#include "JuceHeader.h"
#include "../../Components/BaseComponent.h"
class VenoPreColours : public BaseComponent, public Slider::Listener, Button::Listener
{
public:
VenoPreColours (const std::string& processId);
~VenoPreColours();
void initSliders();
void initButtons();
void sliderValueChanged (Slider* slider) override;
void resized () override;
private:
void buttonClicked (Button* button) override;
protected:
std::shared_ptr<Slider> m_fpsSlider;
std::shared_ptr<Slider> m_scaleSlider;
std::vector<std::unique_ptr<TextButton>> m_pre;
std::string m_names[4]{
"LED", "Blood", "Orange Dream", "Ocean"
};
};
#endif //VENO_VENOPRECOLOURS_H

50
Source/Veno/GUI/Components/LCD/SidebarLCD.cpp
View File

@ -7,56 +7,56 @@
#include "../../../Core/Config.h"
#include "../../../Fonts/Fonts.h"
SidebarLCD::SidebarLCD (const std::string& process_id) : BaseComponent (process_id)
SidebarLCD::SidebarLCD (const std::string& process_id) : BaseComponent(process_id)
{
waveform = std::make_unique<Waveforms> (process_id);
addAndMakeVisible (*waveform);
waveform = std::make_unique<Waveforms>(process_id);
addAndMakeVisible(*waveform);
}
SidebarLCD::~SidebarLCD ()
{
waveform.reset (nullptr);
waveform.reset(nullptr);
}
void SidebarLCD::drawHeadline (Graphics& g)
{
float fontSize = VeNo::Utils::setFontSize (12.0f, g) + 2;
float fontSize = VeNo::Utils::setFontSize(12.0f, g) + 2;
int line = m_innerY + fontSize + 2;
g.drawText (">>> VeNo <<<", 0, m_innerY, getWidth () - m_width, fontSize,
Justification::centred,
true);
g.drawLine (0, line, getWidth (), line);
g.drawText(">>> VeNo <<<", 0, m_innerY, getWidth() - m_width, fontSize,
Justification::centred,
true);
g.drawLine(0, line, getWidth(), line);
}
void SidebarLCD::drawFooter (Graphics& g)
{
float fontSize = VeNo::Utils::setFontSize (8.0f, g) + 4;
float fontSize = VeNo::Utils::setFontSize(8.0f, g) + 4;
int space = m_innerY + fontSize;
int line = getHeight () - space;
g.drawText ("by VersusTuneZ", 0, line, getWidth () - m_width, fontSize,
Justification::horizontallyCentred,
true);
g.drawLine (0, line - 4, getWidth (), line - 4);
int line = getHeight() - space;
g.drawText("by VersusTuneZ", 0, line, getWidth() - m_width, fontSize,
Justification::horizontallyCentred,
true);
g.drawLine(0, line - 4, getWidth(), line - 4);
}
void SidebarLCD::resized ()
{
float topSpace = (12 * Config::getInstance ()->getScale ()) + 4 + m_innerY;
float topSpace = (12 * Config::getInstance()->getScale()) + 4 + m_innerY;
if (waveform != nullptr)
{
waveform->setBounds (0, topSpace * 2, getWidth (), getHeight () - (topSpace * 4));
waveform->setBounds(0, topSpace * 2, getWidth(), getHeight() - (topSpace * 4));
}
}
void SidebarLCD::paint (Graphics& g)
{
std::shared_ptr<Theme> theme = Config::getInstance ()->getCurrentTheme ();
auto colour = theme->getColour (ThemeColour::lcd_bg);
g.fillAll (colour);
std::shared_ptr<Theme> theme = Config::getInstance()->getCurrentTheme();
auto colour = theme->getColour(ThemeColour::lcd_bg);
g.fillAll(colour);
// background
auto accent = theme->getColour (ThemeColour::lcd);
g.setColour (accent);
g.setFont (*VenoFonts::getLCD ());
drawHeadline (g);
drawFooter (g);
auto accent = theme->getColour(ThemeColour::lcd);
g.setColour(accent);
g.setFont(*VenoFonts::getLCD());
drawHeadline(g);
drawFooter(g);
}

214
Source/Veno/GUI/Components/LCD/Waveforms.cpp
View File

@ -9,33 +9,30 @@
#include "../../../VenoInstance.h"
#include "../../../Fonts/Fonts.h"
Waveforms::Waveforms (const std::string& processId) : BaseComponent (processId)
Waveforms::Waveforms (const std::string& processId) : BaseComponent(processId)
{
m_context.setOpenGLVersionRequired (OpenGLContext::OpenGLVersion::openGL3_2);
m_context.setRenderer (this);
m_context.setContinuousRepainting (false);
m_context.setComponentPaintingEnabled (true);
m_context.attachTo (*this);
auto fps = Config::getInstance ()->getFps ();
startTimerHz (Config::getInstance ()->getFps ());
std::srand (unsigned (time (nullptr)));
pickRandomText = (std::rand () % RANDOM_TEXT_COUNT);
setMouseCursor(MouseCursor::PointingHandCursor);
m_context.setOpenGLVersionRequired(OpenGLContext::OpenGLVersion::openGL3_2);
m_context.setRenderer(this);
m_context.setContinuousRepainting(false);
m_context.setComponentPaintingEnabled(true);
m_context.attachTo(*this);
setFps();
std::srand(unsigned(time(nullptr)));
pickRandomText = (std::rand() % RANDOM_TEXT_COUNT);
m_ticks = 0;
// is something that
m_time_needed = roundToInt (4000 / (1000 / fps));
m_time_needed_startup = roundToInt (1000 / (1000 / fps));
}
Waveforms::~Waveforms ()
{
stopTimer ();
shaderProgram.reset ();
m_context.detach ();
stopTimer();
shaderProgram.reset();
m_context.detach();
}
void Waveforms::newOpenGLContextCreated ()
{
compileOpenGLShaderProgram ();
compileOpenGLShaderProgram();
}
void Waveforms::openGLContextClosing ()
@ -45,23 +42,23 @@ void Waveforms::openGLContextClosing ()
void Waveforms::renderOpenGL ()
{
if (!isShowing () || shaderProgram == nullptr || !shaderProgram->getLastError ().isEmpty ())
if (!isShowing() || shaderProgram == nullptr || !shaderProgram->getLastError().isEmpty())
{
return;
}
auto theme = Config::getInstance ()->getCurrentTheme ();
auto theme = Config::getInstance()->getCurrentTheme();
if (theme == nullptr)
{
return;
}
glViewport (0, 0, getWidth (), getHeight ());
OpenGLHelpers::clear (theme->getColour (ThemeColour::lcd_bg));
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shaderProgram->use ();
auto color = theme->getColour (ThemeColour::lcd);
shaderProgram->setUniform ("color", color.getFloatRed (), color.getFloatGreen (), color.getFloatBlue (),
color.getFloatAlpha ());
glViewport(0, 0, getWidth(), getHeight());
OpenGLHelpers::clear(theme->getColour(ThemeColour::lcd_bg));
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shaderProgram->use();
auto color = theme->getColour(ThemeColour::lcd);
shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
color.getFloatAlpha());
if (m_isWelcome || m_isStarting || m_isChangingData)
{
return;
@ -69,33 +66,28 @@ void Waveforms::renderOpenGL ()
switch (m_mode)
{
case 1:
drawAudioOutput ();
drawAudioOutput();
break;
case 2:
drawWaveTable ();
drawWaveTable();
break;
case 3:
drawSpectrum ();
drawSpectrum();
break;
default:
drawPeakMeter ();
drawPeakMeter();
}
}
void Waveforms::handleAsyncUpdate ()
{
}
void Waveforms::compileOpenGLShaderProgram ()
{
std::unique_ptr<OpenGLShaderProgram> shaderProgramAttempt
= std::make_unique<OpenGLShaderProgram> (m_context);
if (shaderProgramAttempt->addVertexShader ({BinaryData::WaveForm_vertex_glsl})
&& shaderProgramAttempt->addFragmentShader ({BinaryData::WaveForm_fragment_glsl})
&& shaderProgramAttempt->link ())
= std::make_unique<OpenGLShaderProgram>(m_context);
if (shaderProgramAttempt->addVertexShader({BinaryData::WaveForm_vertex_glsl})
&& shaderProgramAttempt->addFragmentShader({BinaryData::WaveForm_fragment_glsl})
&& shaderProgramAttempt->link())
{
shaderProgram = std::move (shaderProgramAttempt);
shaderProgram = std::move(shaderProgramAttempt);
}
}
@ -121,15 +113,16 @@ void Waveforms::timerCallback ()
{
if (m_isWelcome || m_isStarting || m_isChangingData || needToClear)
{
repaint ();
repaint();
}
else
{
if (m_context.isAttached ())
if (m_context.isAttached())
{
m_context.triggerRepaint ();
m_context.triggerRepaint();
}
}
setFps();
}
void Waveforms::drawWaveTable ()
@ -140,63 +133,61 @@ void Waveforms::drawWaveTable ()
void Waveforms::drawAudioOutput ()
{
// draw audio from the oscillators
auto instance = VenoInstance::getInstance (BaseComponent::m_processId);
auto buffer = instance->audioBuffer->getBuffer ();
glBegin (GL_LINE_STRIP);
auto instance = VenoInstance::getInstance(BaseComponent::m_processId);
auto buffer = instance->audioBuffer->getBuffer();
glBegin(GL_LINE_STRIP);
float posX = -1;
float inc = 2.0f / buffer.size ();
float inc = 2.0f / buffer.size();
for (float i : buffer)
{
glVertex2f (posX, i);
glVertex2f(posX, i);
posX += inc;
}
glEnd ();
glEnd();
}
void Waveforms::drawPeakMeter ()
{
auto theme = Config::getInstance ()->getCurrentTheme ();
auto theme = Config::getInstance()->getCurrentTheme();
if (theme == nullptr)
{
return;
}
auto instance = VenoInstance::getInstance (BaseComponent::m_processId);
instance->audioBuffer->calcPeak ();
auto instance = VenoInstance::getInstance(BaseComponent::m_processId);
instance->audioBuffer->calcPeak();
// draw peak signal
auto leftChannel = jmap (Decibels::gainToDecibels (instance->audioBuffer->leftPeak, -80.0f), -80.0f, 6.0f, -1.0f,
1.0f);
selectColourByPeak (leftChannel);
glBegin (GL_TRIANGLES);
glVertex2f (-0.9f, leftChannel);
glVertex2f (-0.9f, -1.0f);
glVertex2f (-0.01f, -1.0f);
glVertex2f (-0.9f, leftChannel);
glVertex2f (-0.01f, leftChannel);
glVertex2f (-0.01f, -1.0f);
glEnd ();
auto rightChannel = jmap (Decibels::gainToDecibels (instance->audioBuffer->rightPeak, -80.0f), -80.0f, 6.0f, -1.0f,
1.0f);
selectColourByPeak (rightChannel);
glBegin (GL_TRIANGLES);
glVertex2f (0.9f, rightChannel);
glVertex2f (0.9f, -1.0f);
glVertex2f (0.01f, -1.0f);
glVertex2f (0.9f, rightChannel);
glVertex2f (0.01f, rightChannel);
glVertex2f (0.01f, -1.0f);
glEnd ();
auto leftChannel = getdBForChannel(instance->audioBuffer->leftPeak);
selectColourByPeak(leftChannel);
glBegin(GL_TRIANGLES);
glVertex2f(-0.9f, leftChannel);
glVertex2f(-0.9f, -1.0f);
glVertex2f(-0.01f, -1.0f);
glVertex2f(-0.9f, leftChannel);
glVertex2f(-0.01f, leftChannel);
glVertex2f(-0.01f, -1.0f);
glEnd();
auto rightChannel = getdBForChannel(instance->audioBuffer->rightPeak);
selectColourByPeak(rightChannel);
glBegin(GL_TRIANGLES);
glVertex2f(0.9f, rightChannel);
glVertex2f(0.9f, -1.0f);
glVertex2f(0.01f, -1.0f);
glVertex2f(0.9f, rightChannel);
glVertex2f(0.01f, rightChannel);
glVertex2f(0.01f, -1.0f);
glEnd();
}
void Waveforms::paint (Graphics& g)
{
std::shared_ptr<Theme> theme = Config::getInstance ()->getCurrentTheme ();
auto accent = theme->getColour (ThemeColour::lcd);
g.setColour (accent);
g.setFont (*VenoFonts::getLCD ());
VeNo::Utils::setFontSize (16.0f, g);
std::shared_ptr<Theme> theme = Config::getInstance()->getCurrentTheme();
auto accent = theme->getColour(ThemeColour::lcd);
g.setColour(accent);
g.setFont(*VenoFonts::getLCD());
VeNo::Utils::setFontSize(16.0f, g);
if (m_isWelcome)
{
drawWelcome (g, getWidth (), getHeight (), 0, 0);
drawWelcome(g, getWidth(), getHeight(), 0, 0);
m_ticks++;
if (m_ticks > m_time_needed_startup)
{
@ -207,8 +198,8 @@ void Waveforms::paint (Graphics& g)
}
else if (m_isStarting)
{
g.drawText (m_warmUpText[pickRandomText], 0, 0, getWidth (), getHeight (),
Justification::centred, true);
g.drawText(m_warmUpText[pickRandomText], 0, 0, getWidth(), getHeight(),
Justification::centred, true);
m_ticks++;
if (m_ticks > m_time_needed_startup)
{
@ -219,7 +210,7 @@ void Waveforms::paint (Graphics& g)
}
else if (m_isChangingData)
{
drawChangedParameter (g, getWidth (), getHeight (), 0, 0);
drawChangedParameter(g, getWidth(), getHeight(), 0, 0);
m_ticks++;
if (m_ticks > m_time_needed)
{
@ -230,7 +221,7 @@ void Waveforms::paint (Graphics& g)
}
else
{
g.resetToDefaultState ();
g.resetToDefaultState();
needToClear = false;
}
}
@ -238,19 +229,19 @@ void Waveforms::paint (Graphics& g)
void Waveforms::drawChangedParameter (Graphics& g, int w, int h, int x, int y) const
{
int halfHeight = h / 2;
float font = VeNo::Utils::setFontSize (12, g);
g.drawText (changingParameter, x, y + halfHeight - font, w, font, Justification::centred, true);
g.drawText (std::to_string (changedValue), x, y + halfHeight + 4, w, font, Justification::centred,
true);
float font = VeNo::Utils::setFontSize(12, g);
g.drawText(changingParameter, x, y + halfHeight - font, w, font, Justification::centred, true);
g.drawText(std::to_string(changedValue), x, y + halfHeight + 4, w, font, Justification::centred,
true);
}
void Waveforms::drawWelcome (Graphics& g, int w, int h, int x, int y)
{
float font = VeNo::Utils::setFontSize (12, g);
float font = VeNo::Utils::setFontSize(12, g);
int halfHeight = h / 2;
g.drawText (m_readyText, x, y + halfHeight - font, w, font, Justification::centred, true);
g.drawText (SystemStats::getLogonName (), x, y + halfHeight + 4, w, font, Justification::centred,
true);
g.drawText(m_readyText, x, y + halfHeight - font, w, font, Justification::centred, true);
g.drawText(SystemStats::getLogonName(), x, y + halfHeight + 4, w, font, Justification::centred,
true);
}
void Waveforms::drawSpectrum ()
@ -259,20 +250,39 @@ void Waveforms::drawSpectrum ()
void Waveforms::selectColourByPeak (float value)
{
auto theme = Config::getInstance ()->getCurrentTheme ();
auto theme = Config::getInstance()->getCurrentTheme();
if (theme == nullptr)
{
return;
}
auto color = theme->getColour (ThemeColour::lcd);
if (value > 0.8 && value < 0.9)
{
color = theme->getColour (ThemeColour::warning);
}
auto color = theme->getColour(ThemeColour::lcd);
if (value > 0.9)
{
color = theme->getColour (ThemeColour::clip);
color = theme->getColour(ThemeColour::clip);
}
else if (value > 0.8)
{
color = theme->getColour(ThemeColour::warning);
}
shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
color.getFloatAlpha());
}
float Waveforms::getdBForChannel (float value)
{
float v = VeNo::Utils::clamp(Decibels::gainToDecibels(value, -60.0f), -60.0f, 6.0f);
return jmap(v, -60.0f, 6.0f, -1.0f,
1.0f);
}
void Waveforms::setFps ()
{
if(m_currentFps != Config::getInstance()->getFps()) {
m_currentFps = Config::getInstance()->getFps();
// is something that
m_time_needed = roundToInt(4000 / (1000 / m_currentFps));
m_time_needed_startup = roundToInt(1000 / (1000 / m_currentFps));
stopTimer();
startTimer(m_currentFps);
}
shaderProgram->setUniform ("color", color.getFloatRed (), color.getFloatGreen (), color.getFloatBlue (),
color.getFloatAlpha ());
}

5
Source/Veno/GUI/Components/LCD/Waveforms.h
View File

@ -12,7 +12,6 @@
// opengl context :D
class Waveforms : public BaseComponent,
private OpenGLRenderer,
private AsyncUpdater,
private Timer
{
protected:
@ -34,7 +33,6 @@ public:
void newOpenGLContextCreated () override;
void openGLContextClosing () override;
void renderOpenGL () override;
void handleAsyncUpdate () override;
void mouseDown (const MouseEvent& e) override;
void mouseDrag (const MouseEvent& e) override;
void paint (Graphics& g) override;
@ -51,7 +49,10 @@ private:
void drawWelcome (Graphics& g, int w, int h, int x, int y);
void compileOpenGLShaderProgram ();
void selectColourByPeak (float value);
float getdBForChannel (float value);
void setFps();
OpenGLContext m_context;
std::unique_ptr<OpenGLShaderProgram> shaderProgram;
int m_currentFps = 0;
};
#endif //VENO_WAVEFORMS_H

7
Source/Veno/GUI/Components/LabelComponent.cpp
View File

@ -8,19 +8,20 @@ LabelComponent::LabelComponent (Component* parent, std::string name)
{
m_text = name;
m_parent = parent;
m_label = std::make_shared<Label> (m_parent->getName (), name);
m_label = std::make_shared<Label>(m_parent->getName(), name);
addAndMakeVisible(*m_label);
}
LabelComponent::~LabelComponent ()
{
m_label.reset ();
m_label.reset();
}
void LabelComponent::resized ()
{
if (m_label != nullptr)
{
m_label->setBounds (0, 0, getWidth (), getHeight ());
m_label->setBounds(0, 0, getWidth(), getHeight());
}
}

77
Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.cpp Normal file
View File

@ -0,0 +1,77 @@
//
// Created by versustune on 14.06.20.
//
#include "ConfigComponent.h"
#include <utility>
ConfigComponent::ConfigComponent (std::string pid)
{
m_pid = std::move(pid);
m_colors.resize(8);
auto theme = Config::getInstance()->getCurrentTheme();
for (int i = 0; i < 8; i++)
{
m_colors[i] = std::make_unique<VeNoColour>(pid, getColorForId(i));
m_colors[i]->setName(m_names[i]);
addAndMakeVisible(m_colors[i].get());
}
m_preColours = std::make_unique<VenoPreColours>(pid);
addAndMakeVisible(*m_preColours);
flexBox.flexDirection = FlexBox::Direction::row;
flexBox.justifyContent = FlexBox::JustifyContent::flexStart;
flexBox.flexWrap = FlexBox::Wrap::wrap;
auto w = 200;
auto h = 100;
for (auto& color : m_colors)
{
auto item = FlexItem(w, h, *color);
item.margin = FlexItem::Margin(5, 5, 5, 5);
flexBox.items.add(item);
}
}
ConfigComponent::~ConfigComponent ()
{
for (auto& color : m_colors)
{
color.reset();
}
m_colors.clear();
}
ThemeColour ConfigComponent::getColorForId (int id)
{
switch (id)
{
default:
return ThemeColour::bg;
case 1:
return ThemeColour::bg_two;
case 2:
return ThemeColour::accent;
case 3:
return ThemeColour::accent_two;
case 4:
return ThemeColour::warning;
case 5:
return ThemeColour::clip;
case 6:
return ThemeColour::lcd_bg;
case 7:
return ThemeColour::lcd;
}
}
void ConfigComponent::paint (Graphics& g)
{
g.fillAll(Colours::black);
}
void ConfigComponent::resized ()
{
auto bounds = Rectangle<int>();
bounds.setBounds(0,0,getWidth(), getHeight()-200);
flexBox.performLayout(bounds);
m_preColours->setBounds(0, getHeight() - 200, getWidth(), 200);
}

30
Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.h Normal file
View File

@ -0,0 +1,30 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_CONFIGCOMPONENT_H
#define VENO_CONFIGCOMPONENT_H
#include "JuceHeader.h"
#include "../../../Core/Config.h"
#include "../../Components/Config/VeNoColour.h"
#include "../../Components/Config/VenoPreColours.h"
class ConfigComponent : public Component
{
public:
explicit ConfigComponent(std::string pid);
~ConfigComponent() override;
void paint (Graphics& g) override;
void resized () override;
protected:
static ThemeColour getColorForId(int id);
std::string m_pid;
std::string m_names[8]{
"Background", "BackgroundTwo", "Accent", "Accent Two", "Warning", "Clip", "LCD Background", "LCD"
};
std::vector<std::unique_ptr<VeNoColour>> m_colors;
std::unique_ptr<VenoPreColours> m_preColours;
FlexBox flexBox;
};
#endif //VENO_CONFIGCOMPONENT_H

49
Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.cpp Normal file
View File

@ -0,0 +1,49 @@
//
// Created by versustune on 14.06.20.
//
#include "VenoConfigScreen.h"
#include "../../../VenoInstance.h"
VenoConfigScreen::VenoConfigScreen (const std::string& pid) : DocumentWindow("VeNo Config", Colours::black,
DocumentWindow::closeButton, true)
{
m_pid = pid;
auto w = 840;
auto h = 800;
component = std::make_shared<ConfigComponent>(pid);
component->setSize(w, h);
m_lookHandler = std::make_unique<LookHandler>();
component->setLookAndFeel(m_lookHandler->getLook());
centreWithSize(w, h);
setAlwaysOnTop(true);
setContentOwned(component.get(), false);
setResizable(false, false);
setUsingNativeTitleBar(true);
setVisible(true);
}
VenoConfigScreen::~VenoConfigScreen ()
{
component->setLookAndFeel(nullptr);
m_lookHandler.reset();
component.reset();
}
void VenoConfigScreen::closeButtonPressed ()
{
auto state = VenoInstance::getInstance(m_pid)->state;
if (state != nullptr && state->configScreen != nullptr)
{
delete state->configScreen;
state->configScreen = nullptr;
}
}
void VenoConfigScreen::paint (Graphics& graphics)
{
}
void VenoConfigScreen::resized ()
{
}

28
Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.h Normal file
View File

@ -0,0 +1,28 @@
//
// Created by versustune on 14.06.20.
//
#ifndef VENO_VENOCONFIGSCREEN_H
#define VENO_VENOCONFIGSCREEN_H
#include "JuceHeader.h"
#include "../../../Core/Config.h"
#include "../../Components/Config/VeNoColour.h"
#include "ConfigComponent.h"
class VenoConfigScreen : public DocumentWindow
{
public:
explicit VenoConfigScreen (const std::string& pid);
~VenoConfigScreen () override;
void closeButtonPressed () override;
void paint (Graphics& graphics) override;
void resized () override;
private:
std::string m_pid;
std::shared_ptr<ConfigComponent> component;
std::unique_ptr<LookHandler> m_lookHandler;
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoConfigScreen)
};
#endif //VENO_VENOCONFIGSCREEN_H

45
Source/Veno/GUI/GUIParts/Sidebar/Sidebar.cpp
View File

@ -3,3 +3,48 @@
//
#include "Sidebar.h"
#include "VenoLogo.h"
#include "../../../Utils.h"
Sidebar::Sidebar (const std::string& processId) : BaseComponent(processId)
{
m_lcd = std::make_unique<SidebarLCD>(processId);
m_configButton = std::make_unique<VenoConfigButton>(processId);
addAndMakeVisible(*m_lcd);
addAndMakeVisible(*m_configButton);
}
Sidebar::~Sidebar ()
{
m_lcd.reset(nullptr);
m_configButton.reset(nullptr);
}
void Sidebar::resized ()
{
if (m_lcd != nullptr)
{
m_lcd->setBounds(0, (getWidth() / 5) + 30, getWidth(), VeNo::Utils::getCalculatedHeight(175));
}
if (m_configButton != nullptr)
{
auto height = VeNo::Utils::getCalculatedHeight(30);
auto margin = VeNo::Utils::getCalculatedWidth(10);
m_configButton->setBounds(margin, getHeight()-height-margin, (getWidth()/2)-(margin*2), height);
}
}
void Sidebar::paint (Graphics& g)
{
auto logo = VenoLogo::getInstance()->getLogo();
if (logo.isValid())
{
float height = getWidth() / 5;
g.drawImage(logo, 0, 15, getWidth(), height, 0, 0, 500, 100);
}
else
{
g.setFont(getWidth() / 4);
g.drawSingleLineText("VeNo", 0, 25);
}
}

12
Source/Veno/GUI/GUIParts/Sidebar/Sidebar.h
View File

@ -7,13 +7,21 @@
#include "JuceHeader.h"
#include "../../Components/BaseComponent.h"
#include "../../Components/LCD/SidebarLCD.h"
#include "SidebarMixer.h"
#include "../../Components/Config/VenoConfigButton.h"
class Sidebar : public BaseComponent
{
private:
public:
Sidebar ();
~Sidebar ();
Sidebar (const std::string& processId);
~Sidebar () override;
void resized () override;
void paint (Graphics& g) override;
protected:
std::unique_ptr<SidebarLCD> m_lcd;
std::unique_ptr<SidebarMixer> m_mixer;
std::unique_ptr<VenoConfigButton> m_configButton;
};
#endif //VENO_SIDEBAR_H

36
Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.cpp Normal file
View File

@ -0,0 +1,36 @@
//
// Created by versustune on 14.06.20.
//
#include "VenoLogo.h"
VenoLogo* VenoLogo::instance = nullptr;
VenoLogo* VenoLogo::getInstance ()
{
if (instance == nullptr)
{
instance = new VenoLogo();
}
return instance;
}
VenoLogo::VenoLogo ()
{
MemoryOutputStream mo;
auto result = Base64::convertFromBase64(mo, base64logo);
if (result)
{
realLogo = juce::PNGImageFormat::loadFrom(mo.getData(), mo.getDataSize());
}
}
Image VenoLogo::getLogo ()
{
return getInstance()->realLogo;
}
void VenoLogo::deleteInstance ()
{
delete instance;
}

25
Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.h Normal file
View File

File diff suppressed because one or more lines are too long

17
Source/Veno/GUI/LookAndFeel/FlatLook.cpp
View File

@ -3,3 +3,20 @@
//
#include "FlatLook.h"
#include "../../Core/Config.h"
void FlatLook::drawButtonBackground (Graphics& graphics, Button& button, const Colour& backgroundColour,
bool shouldDrawButtonAsHighlighted, bool shouldDrawButtonAsDown)
{
auto theme = Config::getInstance()->getCurrentTheme();
auto buttonArea = button.getLocalBounds();
if (shouldDrawButtonAsHighlighted)
{
graphics.setColour(theme->getColour(ThemeColour::accent));
}
else
{
graphics.setColour(theme->getColour(ThemeColour::accent_two));
}
graphics.drawRect(buttonArea);
}

2
Source/Veno/GUI/LookAndFeel/FlatLook.h
View File

@ -11,6 +11,8 @@ class FlatLook : public LookAndFeel_V4
{
private:
public:
void drawButtonBackground (Graphics& graphics, Button& button, const Colour& backgroundColour,
bool shouldDrawButtonAsHighlighted, bool shouldDrawButtonAsDown) override;
protected:
};
#endif //VENO_FLATLOOK_H

2
Source/Veno/GUI/LookAndFeel/LookHandler.cpp
View File

@ -7,7 +7,7 @@
LookHandler::LookHandler ()
{
selectLook (Config::getInstance ()->getCurrentLook ());
selectLook(Config::getInstance()->getCurrentLook());
}
LookHandler::~LookHandler ()

2
Source/Veno/GUI/LookAndFeel/LookHandler.h
View File

@ -25,6 +25,6 @@ public:
LookAndFeel_V4* getLook ();
protected:
//currently both available themes are CrazyLook <-- (this is a fun one xD) and FlatLook
LookAndFeel_V4* m_feels[2] = {new FlatLook (), new CrazyLook ()};
LookAndFeel_V4* m_feels[2] = {new FlatLook(), new CrazyLook()};
};
#endif //VENO_LOOKHANDLER_H

66
Source/Veno/GUI/Theme/Theme.cpp
View File

@ -4,6 +4,7 @@
#include "Theme.h"
#include "ThemePresets.cpp"
#include "../../Core/Config.h"
Theme::Theme (std::shared_ptr<PropertiesFile> file)
{
@ -12,8 +13,8 @@ Theme::Theme (std::shared_ptr<PropertiesFile> file)
Theme::~Theme ()
{
m_colours.clear ();
m_configFile.reset ();
m_colours.clear();
m_configFile.reset();
}
void Theme::setColour (ThemeColour index, Colour* colour)
@ -28,37 +29,37 @@ void Theme::setColour (ThemeColour index, Colour* colour)
{
m_colours[index] = colour;
}
m_configFile->setValue (ThemeColourToString (index), colour->toString ());
m_configFile->save ();
m_configFile->setValue(ThemeColourToString(index), colour->toString());
m_configFile->setNeedsToBeSaved(true);
}
void Theme::init ()
{
getColourFromConfig (ThemeColour::bg);
getColourFromConfig (ThemeColour::bg_two);
getColourFromConfig (ThemeColour::accent);
getColourFromConfig (ThemeColour::accent_two);
getColourFromConfig (ThemeColour::warning);
getColourFromConfig (ThemeColour::clip);
getColourFromConfig (ThemeColour::lcd_bg);
getColourFromConfig (ThemeColour::lcd);
getColourFromConfig(ThemeColour::bg);
getColourFromConfig(ThemeColour::bg_two);
getColourFromConfig(ThemeColour::accent);
getColourFromConfig(ThemeColour::accent_two);
getColourFromConfig(ThemeColour::warning);
getColourFromConfig(ThemeColour::clip);
getColourFromConfig(ThemeColour::lcd_bg);
getColourFromConfig(ThemeColour::lcd);
}
void Theme::getColourFromConfig (ThemeColour index)
{
std::string key = ThemeColourToString (index);
if (m_configFile->containsKey (key))
std::string key = ThemeColourToString(index);
if (m_configFile->containsKey(key))
{
auto baseColour = Colour::fromString (m_configFile->getValue (key));
auto* colour = new Colour (baseColour.getRed (), baseColour.getGreen (), baseColour.getBlue ());
auto baseColour = Colour::fromString(m_configFile->getValue(key));
auto* colour = new Colour(baseColour.getRed(), baseColour.getGreen(), baseColour.getBlue());
delete m_colours[index];
m_colours[index] = colour;
}
else
{
// should only trigger if config is broken or empty :)
setLEDTheme (this);
setLEDTheme(this);
}
}
@ -68,7 +69,7 @@ Colour Theme::getColour (ThemeColour index)
{
return *m_colours[index];
}
return Colour (255, 255, 255);
return Colour(255, 255, 255);
}
void Theme::setColourThemeById (int id)
@ -76,17 +77,38 @@ void Theme::setColourThemeById (int id)
switch (id)
{
case 1:
setLEDTheme (this);
setLEDTheme(this);
break;
case 2:
setOrangeDreamTheme (this);
setOrangeDreamTheme(this);
break;
case 3:
setBloodTheme (this);
setBloodTheme(this);
break;
case 4:
setOceanTheme (this);
setOceanTheme(this);
default:
break;
}
}
void Theme::setDefault (const std::string& value)
{
if (value == "LED")
{
setLEDTheme(this);
}
if (value == "Blood")
{
setBloodTheme(this);
}
if (value == "Orange Dream")
{
setOrangeDreamTheme(this);
}
if (value == "Ocean")
{
setOceanTheme(this);
}
Config::getInstance()->repaintAll();
}

1
Source/Veno/GUI/Theme/Theme.h
View File

@ -21,6 +21,7 @@ public:
void setColour (ThemeColour index, Colour* colour);
void setColourThemeById (int id);
void init ();
void setDefault(const std::string& value);
void getColourFromConfig (ThemeColour index);
Colour getColour (ThemeColour index);
protected:

70
Source/Veno/GUI/Theme/ThemePresets.cpp
View File

@ -1,5 +1,7 @@
#include "Theme.h"
#ifndef VENO_THEME_PRESETS
#define VENO_THEME_PRESETS
/*
* this file holds function that read some presets
* in the current Theme class
@ -11,50 +13,50 @@
void setLEDTheme (Theme* theme)
{
theme->setColour (ThemeColour::bg, new Colour (41, 47, 54));
theme->setColour (ThemeColour::bg_two, new Colour (217, 217, 217));
theme->setColour (ThemeColour::accent, new Colour (169, 208, 142));
theme->setColour (ThemeColour::accent_two, new Colour (139, 171, 117));
theme->setColour (ThemeColour::clip, new Colour (255, 23, 68));
theme->setColour (ThemeColour::warning, new Colour (255, 143, 0));
theme->setColour (ThemeColour::lcd_bg, new Colour (21, 21, 21));
theme->setColour (ThemeColour::lcd, new Colour (169, 208, 142));
theme->setColour(ThemeColour::bg, new Colour(41, 47, 54));
theme->setColour(ThemeColour::bg_two, new Colour(217, 217, 217));
theme->setColour(ThemeColour::accent, new Colour(169, 208, 142));
theme->setColour(ThemeColour::accent_two, new Colour(139, 171, 117));
theme->setColour(ThemeColour::clip, new Colour(255, 23, 68));
theme->setColour(ThemeColour::warning, new Colour(255, 143, 0));
theme->setColour(ThemeColour::lcd_bg, new Colour(21, 21, 21));
theme->setColour(ThemeColour::lcd, new Colour(169, 208, 142));
}
void setBloodTheme (Theme* theme)
{
theme->setColour (ThemeColour::bg, new Colour (41, 47, 54));
theme->setColour (ThemeColour::bg_two, new Colour (64, 67, 78));
theme->setColour (ThemeColour::accent, new Colour (180, 38, 50));
theme->setColour (ThemeColour::accent_two, new Colour (115, 47, 64));
theme->setColour (ThemeColour::clip, new Colour (255, 23, 68));
theme->setColour (ThemeColour::warning, new Colour (255, 143, 0));
theme->setColour (ThemeColour::lcd_bg, new Colour (0, 0, 0));
theme->setColour (ThemeColour::lcd, new Colour (180, 38, 78));
theme->setColour(ThemeColour::bg, new Colour(41, 47, 54));
theme->setColour(ThemeColour::bg_two, new Colour(64, 67, 78));
theme->setColour(ThemeColour::accent, new Colour(180, 38, 50));
theme->setColour(ThemeColour::accent_two, new Colour(115, 47, 64));
theme->setColour(ThemeColour::clip, new Colour(255, 23, 68));
theme->setColour(ThemeColour::warning, new Colour(255, 143, 0));
theme->setColour(ThemeColour::lcd_bg, new Colour(0, 0, 0));
theme->setColour(ThemeColour::lcd, new Colour(180, 38, 78));
}
void setOrangeDreamTheme (Theme* theme)
{
theme->setColour (ThemeColour::bg, new Colour (21, 21, 21));
theme->setColour (ThemeColour::bg_two, new Colour (42, 42, 42));
theme->setColour (ThemeColour::accent, new Colour (255, 160, 0));
theme->setColour (ThemeColour::accent_two, new Colour (255, 11, 0));
theme->setColour (ThemeColour::clip, new Colour (255, 23, 68));
theme->setColour (ThemeColour::warning, new Colour (255, 143, 0));
theme->setColour (ThemeColour::lcd_bg, new Colour (33, 33, 33));
theme->setColour (ThemeColour::lcd, new Colour (255, 160, 0));
theme->setColour(ThemeColour::bg, new Colour(21, 21, 21));
theme->setColour(ThemeColour::bg_two, new Colour(42, 42, 42));
theme->setColour(ThemeColour::accent, new Colour(255, 160, 0));
theme->setColour(ThemeColour::accent_two, new Colour(255, 11, 0));
theme->setColour(ThemeColour::clip, new Colour(255, 23, 68));
theme->setColour(ThemeColour::warning, new Colour(255, 143, 0));
theme->setColour(ThemeColour::lcd_bg, new Colour(33, 33, 33));
theme->setColour(ThemeColour::lcd, new Colour(255, 160, 0));
}
void setOceanTheme (Theme* theme)
{
theme->setColour (ThemeColour::bg, new Colour (55, 63, 81));
theme->setColour (ThemeColour::bg_two, new Colour (64, 67, 78));
theme->setColour (ThemeColour::accent, new Colour (0, 141, 213));
theme->setColour (ThemeColour::accent_two, new Colour (0, 129, 194));
theme->setColour (ThemeColour::clip, new Colour (255, 23, 68));
theme->setColour (ThemeColour::warning, new Colour (255, 143, 0));
theme->setColour (ThemeColour::lcd_bg, new Colour (21, 21, 21));
theme->setColour (ThemeColour::lcd, new Colour (0, 129, 194));
theme->setColour(ThemeColour::bg, new Colour(55, 63, 81));
theme->setColour(ThemeColour::bg_two, new Colour(64, 67, 78));
theme->setColour(ThemeColour::accent, new Colour(0, 141, 213));
theme->setColour(ThemeColour::accent_two, new Colour(0, 129, 194));
theme->setColour(ThemeColour::clip, new Colour(255, 23, 68));
theme->setColour(ThemeColour::warning, new Colour(255, 143, 0));
theme->setColour(ThemeColour::lcd_bg, new Colour(21, 21, 21));
theme->setColour(ThemeColour::lcd, new Colour(0, 129, 194));
}
std::string ThemeColourToString (ThemeColour index)
@ -80,4 +82,6 @@ std::string ThemeColourToString (ThemeColour index)
default:
return "";
}
}
}
#endif

56
Source/Veno/Utils.cpp
View File

@ -20,8 +20,58 @@ int VeNo::Utils::nextPowerOfTwo (float value)
float VeNo::Utils::setFontSize (float size, Graphics& g)
{
double scale = Config::getInstance ()->getScale ();
double scale = Config::getInstance()->getScale();
float s = size * scale;
g.setFont (s);
g.setFont(s);
return s;
}
}
float VeNo::Utils::clamp (float value, float min, float max)
{
return value > max ? max : value < min ? min : value;
}
void
VeNo::Utils::setPosition (int width, int height, int x, int y, std::shared_ptr<Component> component, bool useMarginY)
{
double scale = Config::getInstance()->getScale();
double w = width * scale;
double h = height * scale;
if (useMarginY)
{
y += 10;
}
component->setBounds(x + 10, y, w, h);
}
void VeNo::Utils::setPositionSameRow (int width, int height, std::shared_ptr<Component> component,
std::shared_ptr<Component> previous)
{
setPosition(width, height, previous->getX() + previous->getWidth(), previous->getY(), component, false);
}
void VeNo::Utils::setPositionByPreviousRow (int width, int height, int x, std::shared_ptr<Component> component,
std::shared_ptr<Component> previous)
{
setPosition(width, height, x, previous->getY() + previous->getHeight(), component, true);
}
std::vector<int> VeNo::Utils::calcPosition (int width, int height, int prevWidth, int prevHeight)
{
double scale = Config::getInstance()->getScale();
int w = (width * scale);
int h = (height * scale);
int x = prevWidth + 10;
int y = prevHeight + 10;
return {x, y, w, h};
}
int VeNo::Utils::getCalculatedWidth (int width)
{
return width * Config::getInstance()->getScale();
}
int VeNo::Utils::getCalculatedHeight (int height)
{
return height * Config::getInstance()->getScale();
}

10
Source/Veno/Utils.h
View File

@ -15,7 +15,17 @@ namespace VeNo
Utils () = default;
~Utils () = default;
static int nextPowerOfTwo (float value);
static float clamp (float value, float min, float max);
static float setFontSize (float size, Graphics& g);
static void
setPosition (int width, int height, int x, int y, std::shared_ptr<Component> component, bool useMarginY);
static void setPositionSameRow (int width, int height, std::shared_ptr<Component> component,
std::shared_ptr<Component> previous);
static void
setPositionByPreviousRow(int width, int height, int x, std::shared_ptr<Component> component, std::shared_ptr<Component> previous);
static std::vector<int> calcPosition(int width, int height, int prevWidth, int prevHeight);
static int getCalculatedWidth(int width);
static int getCalculatedHeight(int height);
};
}
#endif //VENO_UTILS_H

10
Source/Veno/Utils/FFT.cpp
View File

@ -11,8 +11,8 @@ void FFT::pushNextSampleIntoFifo (float sample) noexcept
{
if (!nextFFTBlockReady) // [12]
{
zeromem (fftData, sizeof (fftData));
memcpy (fftData, fifo, sizeof (fifo));
zeromem(fftData, sizeof(fftData));
memcpy(fftData, fifo, sizeof(fifo));
nextFFTBlockReady = true;
}
fifoIndex = 0;
@ -23,14 +23,14 @@ void FFT::pushNextSampleIntoFifo (float sample) noexcept
void FFT::drawNextFrameOfSpectrum ()
{
window.multiplyWithWindowingTable (fftData, fftSize); // [1]
fft.performFrequencyOnlyForwardTransform (fftData); // [2]
window.multiplyWithWindowingTable(fftData, fftSize); // [1]
fft.performFrequencyOnlyForwardTransform(fftData); // [2]
auto mindB = -80.0f;
auto maxdB = 0.0f;
for (int i = 0; i < scopeSize; ++i)
{
auto level = jmap (Decibels::gainToDecibels (fftData[i], mindB), mindB, maxdB, -1.0f, 1.0f);
auto level = jmap(Decibels::gainToDecibels(fftData[i], mindB), mindB, maxdB, -1.0f, 1.0f);
scopeData[i] = level;
}
}

35
Source/Veno/VenoInstance.cpp
View File

@ -10,33 +10,35 @@ std::unordered_map<std::string, std::shared_ptr<VenoInstance>> VenoInstance::ins
VenoInstance::VenoInstance (std::string id)
{
m_id = std::move (id);
m_synthInstance = std::make_shared<SynthInstance> (id);
audioBuffer = std::make_shared<VenoBuffer> ();
m_id = std::move(id);
m_synthInstance = std::make_shared<SynthInstance>(id);
audioBuffer = std::make_shared<VenoBuffer>();
state = new VeNoState(id);
}
VenoInstance::~VenoInstance ()
{
m_synthInstance.reset ();
audioBuffer.reset ();
m_synthInstance.reset();
audioBuffer.reset();
delete state;
}
std::shared_ptr<VenoInstance> VenoInstance::createInstance (const std::string& id)
{
auto instance = std::make_shared<VenoInstance> (id);
instances.insert (std::pair<std::string, std::shared_ptr<VenoInstance>> (id, instance));
VeNo::Logger::debugMessage ("Created VenoInstance with id: " + id);
auto instance = std::make_shared<VenoInstance>(id);
instances.insert(std::pair<std::string, std::shared_ptr<VenoInstance>>(id, instance));
VeNo::Logger::debugMessage("Created VenoInstance with id: " + id);
return instance;
}
// will return the instance or a empty new on... can find out because the id is fucked!
std::shared_ptr<VenoInstance> VenoInstance::getInstance (const std::string& id)
{
if (instances.find (id) != instances.end ())
if (instances.find(id) != instances.end())
{
return instances[id];
}
return createInstance (id);
return createInstance(id);
}
const std::shared_ptr<SynthInstance>& VenoInstance::getSynthInstance () const
@ -46,10 +48,15 @@ const std::shared_ptr<SynthInstance>& VenoInstance::getSynthInstance () const
void VenoInstance::deleteInstance (const std::string& processId)
{
if (instances.find (processId) != instances.end ())
if (instances.find(processId) != instances.end())
{
instances[processId].reset ();
instances.erase (processId);
VeNo::Logger::debugMessage ("Removed VenoInstance with id: " + processId);
instances[processId].reset();
instances.erase(processId);
VeNo::Logger::debugMessage("Removed VenoInstance with id: " + processId);
}
}
std::unordered_map<std::string, std::shared_ptr<VenoInstance>> VenoInstance::getAll ()
{
return instances;
}

3
Source/Veno/VenoInstance.h
View File

@ -10,6 +10,7 @@
#include "Utils/FFT.h"
#include "Audio/VenoBuffer.h"
#include "Audio/Engine/VenoMatrix.h"
#include "Core/VeNoState.h"
#include <unordered_map>
class VenoInstance
@ -28,5 +29,7 @@ public:
FFT fft;
std::shared_ptr<VenoBuffer> audioBuffer;
VenoMatrix matrix{m_id}; //matrix need a own xml profile to save and restore!
VeNoState* state;
static std::unordered_map<std::string, std::shared_ptr<VenoInstance>> getAll ();
};
#endif //VENO_VENOINSTANCE_H

26
Veno.jucer
View File

@ -75,15 +75,39 @@
</GROUP>
<GROUP id="{EFD25B6B-987D-435F-F8DE-BD6C2B831E62}" name="GUI">
<GROUP id="{9C28E1EA-57BD-A04E-6ED6-3C46B5BC7FC7}" name="GUIParts">
<GROUP id="{D7ABC90B-205D-31C2-67AD-7A31B96627FF}" name="ConfigScreen">
<FILE id="klHmJa" name="ConfigComponent.cpp" compile="1" resource="0"
file="Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.cpp"/>
<FILE id="pYQYBm" name="ConfigComponent.h" compile="0" resource="0"
file="Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.h"/>
<FILE id="aeg3dC" name="VenoConfigScreen.cpp" compile="1" resource="0"
file="Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.cpp"/>
<FILE id="CvExms" name="VenoConfigScreen.h" compile="0" resource="0"
file="Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.h"/>
</GROUP>
<GROUP id="{B7626B9F-22D9-713A-B543-1D7B34AF77B7}" name="Sidebar">
<FILE id="aGx0eJ" name="Sidebar.cpp" compile="1" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/Sidebar.cpp"/>
<FILE id="uL7MJ3" name="Sidebar.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/Sidebar.h"/>
<FILE id="lNXOQs" name="SidebarMixer.cpp" compile="1" resource="0"
file="Source/Veno/GUI/GUIParts/Sidebar/SidebarMixer.cpp"/>
<FILE id="onzdTZ" name="SidebarMixer.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/SidebarMixer.h"/>
<FILE id="w3JFHK" name="VenoLogo.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.h"/>
<FILE id="AE7YqM" name="VenoLogo.cpp" compile="1" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.cpp"/>
</GROUP>
</GROUP>
<GROUP id="{53C33AC6-67D7-762E-FFD5-C82B7F51DA5F}" name="Components">
<GROUP id="{90BA3743-01F8-1537-6D24-1C38F4063F10}" name="Config">
<FILE id="SRKqRQ" name="VeNoColour.cpp" compile="1" resource="0" file="Source/Veno/GUI/Components/Config/VeNoColour.cpp"/>
<FILE id="Da4NUN" name="VeNoColour.h" compile="0" resource="0" file="Source/Veno/GUI/Components/Config/VeNoColour.h"/>
<FILE id="zC4cQd" name="VenoConfigButton.cpp" compile="1" resource="0"
file="Source/Veno/GUI/Components/Config/VenoConfigButton.cpp"/>
<FILE id="kCWitN" name="VenoConfigButton.h" compile="0" resource="0"
file="Source/Veno/GUI/Components/Config/VenoConfigButton.h"/>
<FILE id="Yxj8Nf" name="VenoPreColours.cpp" compile="1" resource="0"
file="Source/Veno/GUI/Components/Config/VenoPreColours.cpp"/>
<FILE id="DbGZt9" name="VenoPreColours.h" compile="0" resource="0"
file="Source/Veno/GUI/Components/Config/VenoPreColours.h"/>
</GROUP>
<GROUP id="{7C37E6D2-F2F7-6BF7-5D9B-2DDABFFE993F}" name="LCD">
<FILE id="LpeTfD" name="SidebarLCD.cpp" compile="1" resource="0" file="Source/Veno/GUI/Components/LCD/SidebarLCD.cpp"/>
<FILE id="Y5kUlM" name="SidebarLCD.h" compile="0" resource="0" file="Source/Veno/GUI/Components/LCD/SidebarLCD.h"/>
@ -121,6 +145,8 @@
<FILE id="i3vbdH" name="PresetManager.cpp" compile="1" resource="0"
file="Source/Veno/Core/PresetManager.cpp"/>
<FILE id="WV2uuz" name="PresetManager.h" compile="0" resource="0" file="Source/Veno/Core/PresetManager.h"/>
<FILE id="Wvf9em" name="VeNoState.cpp" compile="1" resource="0" file="Source/Veno/Core/VeNoState.cpp"/>
<FILE id="skv4zn" name="VeNoState.h" compile="0" resource="0" file="Source/Veno/Core/VeNoState.h"/>
</GROUP>
</GROUP>
<FILE id="zASeb7" name="PluginProcessor.cpp" compile="1" resource="0"