- reformat to JUCE-Guidelines

- added Matrix => half working ;)

Source/Veno/Audio/Engine/ModulateValue.cpp

@@ -0,0 +1,21 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#include "ModulateValue.h"
+
+ModulateValue::ModulateValue (const std::string& name, const std::string& processId)
+{
+    m_name = name;
+    m_processId = processId;
+}
+
+void ModulateValue::addValue (float d)
+{
+
+}
+
+ModulateValue::~ModulateValue ()
+{
+
+}

Source/Veno/Audio/Engine/ModulateValue.h

@@ -0,0 +1,25 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#ifndef VENO_MODULATEVALUE_H
+#define VENO_MODULATEVALUE_H
+
+#include <string>
+
+// a class that is used to can handle the value from a "gui-part" and the matrix and all other modulation
+class ModulateValue
+{
+public:
+    ModulateValue (const std::string& name, const std::string& processId);
+    ~ModulateValue ();
+    void addValue (float d);
+private:
+    std::string m_name;
+    std::string m_processId;
+    float m_value;
+    float m_baseValue = 0;
+    float m_maxValue = 1;
+    float m_minValue = -1;
+};
+#endif //VENO_MODULATEVALUE_H

Source/Veno/Audio/Engine/Modulator.cpp

@@ -0,0 +1,24 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#include "Modulator.h"
+
+float Modulator::getValue ()
+{
+    return m_value;
+}
+
+Modulator::Modulator ()
+{
+
+}
+
+Modulator::~Modulator ()
+{
+
+}
+
+void Modulator::update ()
+{
+}

Source/Veno/Audio/Engine/Modulator.h

@@ -0,0 +1,19 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#ifndef VENO_MODULATOR_H
+#define VENO_MODULATOR_H
+// class that define if it can be a modulator on not
+// like LFO, Envelope, maybe also OSCILLATORS :P VELOCITY AND OTHER STUFF IS ALSO A MODULATOR!
+class Modulator
+{
+public:
+    Modulator ();
+    ~Modulator ();
+    float getValue ();
+    void update ();
+protected:
+    float m_value;
+};
+#endif //VENO_MODULATOR_H

Source/Veno/Audio/Engine/VenoMatrix.cpp

@@ -0,0 +1,81 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#include "VenoMatrix.h"
+
+VenoMatrix::VenoMatrix (const std::string& processId) : m_processId (processId)
+{
+    for (auto& m_slot : m_slots)
+    {
+        m_slot = new VenoMatrixSlot ();
+    }
+}
+
+VenoMatrix::~VenoMatrix ()
+{
+    for (auto& m_slot : m_slots)
+    {
+        delete m_slot;
+    }
+}
+
+VenoMatrixSlot* VenoMatrix::getSlotById (int id)
+{
+    return m_slots[id];
+}
+
+void VenoMatrix::removeModulateValue (const std::string& name)
+{
+    m_modulationValues.erase (name);
+}
+
+void VenoMatrix::removeModulator (const std::string& 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));
+}
+
+void VenoMatrix::addModulator (const std::string& name, Modulator* modulator)
+{
+    m_modulators.emplace (std::pair<const std::string&, Modulator*> (name, modulator));
+}
+
+void VenoMatrix::updateSlots ()
+{
+    for (auto& m_slot : m_slots)
+    {
+        if (m_slot->sourceName == "none")
+        {
+            continue;
+        }
+        if (m_modulators.find (m_slot->sourceName) != m_modulators.end ())
+        {
+            auto modulator = m_modulators[m_slot->sourceName];
+            if (modulator == nullptr)
+            {
+                continue;
+            }
+            modulator->update ();
+            for (auto& value : m_slot->targets)
+            {
+                if (value.name != "none")
+                {
+                    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);
+                    }
+                }
+            }
+        }
+    }
+}

Source/Veno/Audio/Engine/VenoMatrix.h

@@ -0,0 +1,42 @@
+//
+// Created by versustune on 13.06.20.
+//
+
+#ifndef VENO_VENOMATRIX_H
+#define VENO_VENOMATRIX_H
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "Modulator.h"
+#include "ModulateValue.h"
+
+// class that modulate everything :D
+struct VenoMatrixTarget
+{
+    std::string name;
+    float amount = 0; // always 0 to 1 <-- apply amount to modulator
+};
+struct VenoMatrixSlot
+{
+    std::string sourceName;
+    VenoMatrixTarget targets[8];
+};
+class VenoMatrix
+{
+public:
+    explicit VenoMatrix (const std::string& processId);
+    ~VenoMatrix ();
+    void updateSlots ();
+    void addModulator (const std::string& name, Modulator* modulator);
+    void addModulateValue (const std::string& name, ModulateValue* modulateValue);
+    void removeModulator (const std::string& name);
+    void removeModulateValue (const std::string& name);
+    VenoMatrixSlot* getSlotById (int id);
+private:
+    std::unordered_map<std::string, Modulator*> m_modulators; //all sources
+    std::unordered_map<std::string, ModulateValue*> m_modulationValues;
+    VenoMatrixSlot* m_slots[8]{}; // 8 source slots
+    std::string m_processId;
+};
+#endif //VENO_VENOMATRIX_H