Add bus nodes for multiplexing data. Also add imgui plot output nodes…

… that will be used as graph sources.

packages/nodegraph/include/nodegraph/NodeGraphSchema.h

@@ -12,6 +12,7 @@
 #include "nodegraph/operations/NodeGraphOpOutput.h"
 #include "nodegraph/operations/NodeGraphOpSource.h"
 #include "nodegraph/operations/NodeGraphOpSignal.h"
+#include "nodegraph/operations/NodeGraphOpDataBus.h"
 
 #include <string>
 #include <vector>
@@ -52,6 +53,7 @@ namespace l::nodegraph {
                 RegisterAllOf("Input");
                 RegisterAllOf("Signal");
                 RegisterAllOf("Control");
+                RegisterAllOf("Bus");
             }
         }
 

packages/nodegraph/include/nodegraph/operations/NodeGraphOpDataBus.h

@@ -0,0 +1,63 @@
+#pragma once
+#include "nodegraph/core/NodeGraphBase.h"
+
+#include "logging/LoggingAll.h"
+
+#include "hid/KeyboardPiano.h"
+#include "hid/Midi.h"
+
+#include "audio/PortAudio.h"
+#include "audio/AudioUtils.h"
+
+#include "math/MathFunc.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <typeinfo>
+#include <type_traits>
+#include <math.h>
+#include <random>
+#include <unordered_set>
+
+namespace l::nodegraph {
+
+    /*********************************************************************/
+    class GraphDataBusDataIn : public NodeGraphOp2 {
+    public:
+        GraphDataBusDataIn(NodeGraphBase* node, int32_t inputDataStride) :
+            NodeGraphOp2(node, "Bus Data In x6"),
+            mInputDataStride(inputDataStride)
+        {
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("Bus Data", 0.0f, 2));
+
+            for (int32_t i = 0; i < mInputDataStride; i++) {
+                AddOutput("Out " + std::to_string(i), 0.0f, 2);
+            }
+        }
+
+        virtual void Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) override;
+    protected:
+        int32_t mInputDataStride = 1;
+    };
+
+    /*********************************************************************/
+    class GraphDataBusDataOut : public NodeGraphOp2 {
+    public:
+        GraphDataBusDataOut(NodeGraphBase* node, int32_t outputDataStride) :
+            NodeGraphOp2(node, "Bus Data Out x6"),
+            mOutputDataStride(outputDataStride)
+        {
+            for (int32_t i = 0; i < mOutputDataStride; i++) {
+                mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("In " + std::to_string(i), 0.0f, 2));
+            }
+            AddOutput("Bus Data", 0.0f, 2);
+        }
+
+        virtual void Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) override;
+    protected:
+        int32_t mOutputDataStride = 1;
+    };
+
+}
+

packages/nodegraph/include/nodegraph/operations/NodeGraphOpOutput.h

@@ -91,5 +91,41 @@ namespace l::nodegraph {
         int32_t mCurIndex = 0;
     };
 
+    /*********************************************************************/
+    class GraphOutputImGuiPlotLine : public NodeGraphOp2 {
+    public:
+        GraphOutputImGuiPlotLine(NodeGraphBase* node) :
+            NodeGraphOp2(node, "ImGui Plot Line")
+        {
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("x", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("y", 0.0f));
+            AddOutput("Lines");
+        }
+        virtual ~GraphOutputImGuiPlotLine() = default;
+
+        virtual void Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) override;
+    protected:
+    };
+
+    /*********************************************************************/
+    class GraphOutputImGuiPlotCandles : public NodeGraphOp2 {
+    public:
+        GraphOutputImGuiPlotCandles(NodeGraphBase* node) :
+            NodeGraphOp2(node, "ImGui Plot Candles")
+        {
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("unixtime", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("open", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("close", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("high", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("low", 0.0f));
+            mInputManager.AddInput(InputIterationType::SAMPLED, AddInput("volume", 0.0f));
+            AddOutput("Candles");
+        }
+        virtual ~GraphOutputImGuiPlotCandles() = default;
+
+        virtual void Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) override;
+    protected:
+    };
+
 }
 

packages/nodegraph/source/common/NodeGraphSchema.cpp

@@ -95,6 +95,12 @@ namespace l::nodegraph {
         case 202:
             node = mMainNodeGraph.NewNode<l::nodegraph::GraphOutputPlot>(OutputType::ExternalVisualOutput, 100);
             break;
+        case 203:
+            node = mMainNodeGraph.NewNode<l::nodegraph::GraphOutputImGuiPlotLine>(OutputType::ExternalOutput);
+            break;
+        case 204:
+            node = mMainNodeGraph.NewNode<l::nodegraph::GraphOutputImGuiPlotCandles>(OutputType::ExternalOutput);
+            break;
 
         case 251:
             node = mMainNodeGraph.NewNode<l::nodegraph::GraphEffectReverb1>(OutputType::Default);
@@ -169,6 +175,13 @@ namespace l::nodegraph {
             node = mMainNodeGraph.NewNode<l::nodegraph::GraphControlArpeggio>(OutputType::Default);
             break;
 
+        case 450:
+            node = mMainNodeGraph.NewNode<l::nodegraph::GraphDataBusDataIn>(OutputType::Default, 6);
+            break;
+        case 451:
+            node = mMainNodeGraph.NewNode<l::nodegraph::GraphDataBusDataOut>(OutputType::ExternalOutput, 6);
+            break;
+
         default:
             ASSERT(typeId < 10000) << "Custom node id's begin at id 1000";
             if (mCreateCustomNode) {
@@ -245,6 +258,8 @@ namespace l::nodegraph {
             RegisterNodeType("Output", 200, "Debug");
             RegisterNodeType("Output", 201, "Speaker");
             RegisterNodeType("Output", 202, "Plot");
+            RegisterNodeType("Output", 203, "ImGui Plot Lines");
+            RegisterNodeType("Output", 204, "ImGui Plot Candles");
         }
         else if (typeGroup == "Effect") {
             RegisterNodeType("Effect", 251, "Reverb1");
@@ -277,6 +292,10 @@ namespace l::nodegraph {
             RegisterNodeType("Control", 400, "Envelope");
             RegisterNodeType("Control", 401, "Arpeggio");
         }
+        else if (typeGroup == "Bus") {
+            RegisterNodeType("Bus", 450, "Bus Data In x6");
+            RegisterNodeType("Bus", 451, "Bus Data Out x6");
+        }
     }
 
     void NodeGraphSchema::Tick(int32_t tickCount, float deltaTime) {

packages/nodegraph/source/common/core/NodeGraphBase.cpp

@@ -330,31 +330,49 @@ namespace l::nodegraph {
     }
 
     bool NodeGraphOp::IsDataConstant(int8_t channel) {
-        return std::get<4>(mDefaultInData.at(channel));
+        if (channel < mDefaultInData.size()) {
+            return std::get<4>(mDefaultInData.at(channel));
+        }
+        return false;
     }
 
     bool NodeGraphOp::IsDataVisible(int8_t channel) {
-        return std::get<5>(mDefaultInData.at(channel));
+        if (channel < mDefaultInData.size()) {
+            return std::get<5>(mDefaultInData.at(channel));
+        }
+        return false;
     }
 
     bool NodeGraphOp::IsDataEditable(int8_t channel) {
-        return std::get<6>(mDefaultInData.at(channel));
+        if (channel < mDefaultInData.size()) {
+            return std::get<6>(mDefaultInData.at(channel));
+        }
+        return false;
     }
 
     std::string_view NodeGraphOp::GetInputName(int8_t inputChannel) {
-        return mDefaultInStrings[inputChannel];
+        if (inputChannel < mDefaultInStrings.size()) {
+            return mDefaultInStrings[inputChannel];
+        }
+        return "";
     }
 
     std::string_view NodeGraphOp::GetOutputName(int8_t outputChannel) {
-        return mDefaultOutStrings[outputChannel];
+        if (outputChannel < mDefaultOutStrings.size()) {
+            return mDefaultOutStrings[outputChannel];
+        }
+        return "";
     }
 
     std::string_view NodeGraphOp::GetName() {
         return mName;
     }
 
     float NodeGraphOp::GetDefaultData(int8_t inputChannel) {
-        return std::get<0>(mDefaultInData.at(inputChannel));
+        if (inputChannel < mDefaultInData.size()) {
+            return std::get<0>(mDefaultInData.at(inputChannel));
+        }
+        return 0.0f;
     }
 
     int32_t NodeGraphOp::AddInput(std::string_view name, float defaultValue, int32_t size, float boundMin, float boundMax, bool visible, bool editable) {

packages/nodegraph/source/common/core/NodeGraphInput.cpp

@@ -214,17 +214,11 @@ namespace l::nodegraph {
     }
 
     float InputAccessor::GetArrayValue(int32_t index) {
-        if (mType == InputIterationType::CONSTANT_ARRAY) {
-            return mInput.mIterator[index];
-        }
-        return 0.0f;
+        return mInput.mIterator[index];
     }
 
     float* InputAccessor::GetArray() {
-        if (mType == InputIterationType::CONSTANT_ARRAY) {
-            return mInput.mIterator.data();
-        }
-        return nullptr;
+        return mInput.mIterator.data();
     }
 
     // run on each new batch call to setup input iterators for buffered data

packages/nodegraph/source/common/operations/NodeGraphOpDataBus.cpp

@@ -0,0 +1,38 @@
+#include "nodegraph/operations/NodeGraphOpDataBus.h"
+
+#include "logging/Log.h"
+#include "audio/AudioUtils.h"
+
+#include "math/MathFunc.h"
+
+#include <math.h>
+
+namespace l::nodegraph {
+
+    /*********************************************************************/
+    void GraphDataBusDataIn::Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) {
+        mInputManager.BatchUpdate(inputs, mInputDataStride * numSamples);
+
+        float* input = mInputManager.GetArray(0);
+        for (int32_t i = 0; i < mInputDataStride; i++) {
+            float* output = &outputs.at(i).Get(numSamples);
+            for (int32_t j = 0; j < numSamples; j++) {
+                output[j] = input[mInputDataStride * j + i];
+            }
+        }
+    }
+
+    /*********************************************************************/
+    void GraphDataBusDataOut::Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) {
+        mInputManager.BatchUpdate(inputs, numSamples);
+
+        float* output = &outputs.at(0).Get(mOutputDataStride * numSamples);
+        for (int32_t i = 0; i < numSamples; i++) {
+            for (int32_t j = 0; j < mOutputDataStride; j++) {
+                output[mOutputDataStride * i + j] = mInputManager.GetValueNext(j);
+            }
+        }
+    }
+
+
+}

packages/nodegraph/source/common/operations/NodeGraphOpOutput.cpp

@@ -98,4 +98,32 @@ namespace l::nodegraph {
         }
     }
 
+    /*********************************************************************/
+    void GraphOutputImGuiPlotLine::Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) {
+        mInputManager.BatchUpdate(inputs, numSamples);
+
+        float* output = &outputs.at(0).Get(2 * numSamples);
+
+        for (int32_t i = 0; i < numSamples; i++) {
+            output[2 * i + 0] = mInputManager.GetValueNext(0);
+            output[2 * i + 1] = mInputManager.GetValueNext(1);
+        }
+    }
+
+    /*********************************************************************/
+    void GraphOutputImGuiPlotCandles::Process(int32_t numSamples, std::vector<NodeGraphInput>& inputs, std::vector<NodeGraphOutput>& outputs) {
+        mInputManager.BatchUpdate(inputs, numSamples);
+
+        float* output = &outputs.at(0).Get(6 * numSamples);
+
+        for (int32_t i = 0; i < numSamples; i++) {
+            output[6 * i + 0] = mInputManager.GetValueNext(0);
+            output[6 * i + 1] = mInputManager.GetValueNext(1);
+            output[6 * i + 2] = mInputManager.GetValueNext(2);
+            output[6 * i + 3] = mInputManager.GetValueNext(3);
+            output[6 * i + 4] = mInputManager.GetValueNext(4);
+            output[6 * i + 5] = mInputManager.GetValueNext(5);
+        }
+    }
+
 }

packages/rendering/source/common/ui/UICreator.cpp

@@ -34,7 +34,7 @@ namespace l::ui {
                 connector1Text->GetContainerArea().mRender.mColor = ImColor(ImVec4(0.5f, 1.0f, 0.4f, 1.0f));
                 row0->Add(connector1Text);
             }
-            for (int8_t i = 0; i < numInputChannels || i < numOutputChannels || i < numInputChannels || i < numOutputChannels; i++) {
+            for (int8_t i = 0; i < numInputChannels || i < numOutputChannels; i++) {
                 auto row = CreateContainer(uiManager, 0, l::ui::UIRenderType::Rect, l::ui::UIAlignH::Left, l::ui::UIAlignV::Top, l::ui::UILayoutH::Parent, l::ui::UILayoutV::Fixed);
                 row->GetContainerArea().mMargin = ioSize;
                 node4->Add(row);