Add a neuron on Space

Default area size is a cube of 20 neurons per side

Author: mikolasan

graphics/neurons/network.cpp

@@ -4,6 +4,9 @@
 #include "render/neuron_render.hpp"
 #include "render/network_render.h"
 
+Network::Network() {
+    layers.push_back({});
+}
 
 void Network::addLayer(const NeuronLayer&& layer, const std::vector<size_t>& area_size) {
     layers.push_back(layer);
@@ -21,10 +24,11 @@ void Network::addLayer(const NeuronLayer&& layer, const std::vector<size_t>& are
     }
 }
 
-void Network::addNeuron(const std::vector<size_t>& pos, const NeuronLayer& connected_to) {
+void Network::addNeuron(const std::vector<int32_t>& pos, const NeuronLayer& connected_to) {
     uint32_t layer = pos[2];
     if (layer >= layers.size()) {
-        std::cerr << "wrong layer position\n";
+        layers.insert(layers.end(), layers.size() - layer + 1, {});
+        // std::cerr << "wrong layer position\n";
         return;
     }
 
@@ -106,7 +110,7 @@ void Network::init() {
     if (render) render->init();
 }
 
-void Network::draw(float time) const {
+void Network::draw(float time) {
     if (render) render->draw(time);
 }
 

graphics/neurons/network.h

@@ -26,10 +26,10 @@ struct Network {
 
     std::shared_ptr<RenderStrategy> render;
 
-    explicit Network() = default;
+    explicit Network();
 
     void addLayer(const NeuronLayer&& layer, const std::vector<size_t>& area_size);
-    void addNeuron(const std::vector<size_t>& pos, const NeuronLayer& connected_to);
+    void addNeuron(const std::vector<int32_t>& pos, const NeuronLayer& connected_to);
     void addConnection(const std::shared_ptr<Neuron>& n1,
         const std::shared_ptr<Neuron>& n2);
 
@@ -39,7 +39,7 @@ struct Network {
     std::vector<float> get_current_voltage_state() const;
     void step(std::vector<uint8_t> inputs);
     void init();
-    void draw(float time) const;
+    void draw(float time);
     void update(float dt);
     void destroy() const;
 

graphics/neurons/neuron.hpp

@@ -26,7 +26,7 @@ struct Neuron {
         if (render) render->update(dt);
     }
 
-    void draw(float time) const {
+    void draw(float time) {
         if (render) render->draw(time);
     }
 

graphics/neurons/render/network_render.cpp

@@ -4,6 +4,7 @@
 #include "network_render.h"
 #include "neuron_render.hpp"
 
+
 void NetworkRenderStrategy::init() {
     m_lastFrameMissing = 0;
     // 80 bytes stride = 64 bytes for 4x4 matrix + 16 bytes for RGBA color.
@@ -92,18 +93,26 @@ void NetworkRenderStrategy::update(float dt) {
     if (ImGui::IsKeyPressed(ImGuiKey_W))
         selected_y = std::max(0, selected_y - 1);
     if (ImGui::IsKeyPressed(ImGuiKey_S))
-        selected_y = std::min(area_size_y - 1, selected_y + 1);
+        selected_y = std::min(max_area_size - 1, selected_y + 1);
 
     if (ImGui::IsKeyPressed(ImGuiKey_A))
         selected_x = std::max(0, selected_x - 1);
     if (ImGui::IsKeyPressed(ImGuiKey_D))
-        selected_x = std::min(area_size_x - 1, selected_x + 1);
+        selected_x = std::min(max_area_size - 1, selected_x + 1);
 
     if (ImGui::IsKeyPressed(ImGuiKey_R))
-        selected_x = std::max(0, selected_z - 1);
+        selected_z = std::max(0, selected_z - 1);
     if (ImGui::IsKeyPressed(ImGuiKey_F))
-        selected_x = std::min(area_size_z - 1, selected_z + 1);
+        selected_z = std::min(max_area_size - 1, selected_z + 1);
+    
+    if (ImGui::IsKeyPressed(ImGuiKey_Space)) {
+        std::vector<int32_t> pos = { selected_x, selected_y, selected_z };
+        if (selected_neuron == nullptr) {
+            // create neuron
+            ctx->net.addNeuron(pos, {});
+        }
 
+    }
         // to total number of instances to draw
     uint32_t totalCubes = ctx->net.neurons.size();
 
@@ -119,7 +128,7 @@ void NetworkRenderStrategy::update(float dt) {
     }
 }
 
-void NetworkRenderStrategy::drawNeurons(float time) const {
+void NetworkRenderStrategy::drawNeurons(float time) {
     bgfx::InstanceDataBuffer idb;
     bgfx::allocInstanceDataBuffer(&idb, drawnCubes, instanceStride);
 
@@ -130,14 +139,22 @@ void NetworkRenderStrategy::drawNeurons(float time) const {
     const float start_y = - area_size_y * offset / 2.0f;
     const float start_z = - area_size_z * offset / 2.0f;
 
+    // reset the selection
+    selected_neuron = nullptr;
+
     for (uint32_t ii = 0; ii < drawnCubes; ++ii)
     {
         const auto& neuron = ctx->net.neurons[ii];
 
         std::shared_ptr<NeuronRenderStrategy>& s = std::dynamic_pointer_cast<NeuronRenderStrategy>(neuron->render);
         bx::Vec3 pos = s->get_position();
-        uint32_t yy = pos.y;
         uint32_t xx = pos.x;
+        uint32_t yy = pos.y;
+        uint32_t zz = pos.z;
+
+        if (xx == selected_x && yy == selected_y && zz == selected_z) {
+            selected_neuron = neuron;
+        }
 
         float* mtx = (float*)data;
         time = 0.0f;
@@ -156,7 +173,7 @@ void NetworkRenderStrategy::drawNeurons(float time) const {
 
         mtx[12] = start_x + float(xx) * offset;
         mtx[13] = start_y + float(yy) * offset;
-        mtx[14] = 0.0f;
+        mtx[14] = start_z + float(zz) * offset;
 
         float* color = (float*)&data[64];
 
@@ -187,7 +204,7 @@ void NetworkRenderStrategy::drawNeurons(float time) const {
     bgfx::submit(0, m_program);
 }
 
-void NetworkRenderStrategy::drawSelection(float time) const {
+void NetworkRenderStrategy::drawSelection(float time) {
 
     const float offset = 3.0f;
     const float start_x = - area_size_x * offset / 2.0f;
@@ -215,7 +232,7 @@ void NetworkRenderStrategy::drawSelection(float time) const {
     bgfx::submit(0, m_selection_program);
 }
 
-void NetworkRenderStrategy::draw(float time) const {
+void NetworkRenderStrategy::draw(float time) {
     if (drawnCubes > 0) {
         drawNeurons(time);
     }

graphics/neurons/render/network_render.h

@@ -9,7 +9,7 @@
 #include "network.h"
 #include "render_strategy.h"
 
-
+const int32_t max_area_size = 20;
 
 struct NetworkVisualContext : VisualContext {
     // std::vector<bx::Vec3> positions;
@@ -34,11 +34,11 @@ struct NetworkRenderStrategy : RenderStrategy {
     void init() override;
     void addLayer(const NeuronLayer& layer, const std::vector<size_t>& area_size);
     void update(float dt) override;
-    void draw(float time) const override;
+    void draw(float time) override;
     void destroy() override;
 
-    void drawNeurons(float time) const;
-    void drawSelection(float time) const;
+    void drawNeurons(float time);
+    void drawSelection(float time);
 
     bgfx::VertexBufferHandle m_vbh;
     bgfx::IndexBufferHandle  m_ibh;
@@ -57,6 +57,7 @@ struct NetworkRenderStrategy : RenderStrategy {
     int32_t selected_x = 0;
     int32_t selected_y = 0;
     int32_t selected_z = 0;
+    std::shared_ptr<Neuron> selected_neuron;
 
     float m_color[4];
     bgfx::UniformHandle u_color;

graphics/neurons/render/neuron_render.hpp

@@ -69,7 +69,7 @@ struct NeuronRenderStrategy : RenderStrategy {
     // Optional: nothing for now
   }
 
-  void draw(float time) const override {
+  void draw(float time) override {
     // size_t idx = ctx->idx;
     // const bx::Vec3& pos = ctx->positions[idx];
 

graphics/neurons/render_strategy.h

@@ -11,7 +11,7 @@ struct VisualContext {};
 struct RenderStrategy {
     virtual void init() = 0;
     virtual void update(float dt) = 0;
-    virtual void draw(float time) const = 0;
+    virtual void draw(float time) = 0;
     virtual void destroy() = 0;
     virtual ~RenderStrategy() = default;
 };