add knightrider

Author: wind0r

config.yml

@@ -51,6 +51,11 @@ operations:
     params:
       enabled: false
       duration: 5000
+  knightrider:
+    type: knightrider
+    params:
+      duration: 5000
+      width: 0.2
   rotate:
     type: rotate
     params:

src/config_sequence.cpp

@@ -8,6 +8,7 @@
 #include "operations/FlashOperation.h"
 #include "operations/GameOfLifeOperation.h"
 #include "operations/HSVUDPInputOperation.h"
+#include "operations/KnightRider.h"
 #include "operations/RainbowOperation.h"
 #include "operations/RaindropOperation.h"
 #include "operations/RotateOperation.h"
@@ -45,6 +46,7 @@ std::unique_ptr<Operation> generateSequenceStep(
       {"gameoflife", &generator<GameOfLifeOperation>},
       {"hsvudpinput", &generator<HSVUDPInputOperation>},
       {"lua", &generator<LuaOperation>},
+      {"knightrider", &generator<KnightRiderOperation>},
       {"rainbow", &generator<RainbowOperation>},
       {"raindrop", &generator<RaindropOperation>},
       {"rotate", &generator<RotateOperation>},

src/operations/KnightRider.cpp

@@ -0,0 +1,89 @@
+#include "KnightRider.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+
+#include <iostream>
+#include <iomanip>
+
+KnightRiderOperation::KnightRiderOperation(const std::string& name,
+                                           std::shared_ptr<VariableStore> store,
+                                           YAML::const_iterator begin,
+                                           YAML::const_iterator end)
+    : Operation(name, store, begin, end),
+      state(State::IDLE),
+      hue(name + "/hue",
+          Operation::HSV_HUE,
+          store,
+          getValueByKey<float>("hue", begin, end, 0.0f)),
+      saturation(name + "/saturation",
+                 Operation::HSV_SATURATION,
+                 store,
+                 getValueByKey<float>("saturation", begin, end, 1.0f)),
+      value(name + "/value",
+            Operation::HSV_VALUE,
+            store,
+            getValueByKey<float>("value", begin, end, 1.0f)),
+      duration_milliseconds(name + "/duration",
+                            Operation::INT,
+                            store,
+                            getValueByKey<int>("duration", begin, end, 1000)),
+      width(name + "/width",
+                  Operation::FLOAT,
+                  store,
+                  getValueByKey<float>("width", begin, end, 0.1f)) {}
+
+Operation::BufferType KnightRiderOperation::operator()(
+    Operation::BufferType& buffer) {
+  if (!isEnabled())
+    return buffer;
+
+  int size = (*buffer).size();
+
+  for (int i = 0; i < size; i++) {
+    if (direction == Direction::ASCENDING && i > currentCenter) {
+      break;
+    }
+
+    if (direction == Direction::DESCENDING && i < currentCenter) { 
+      i = currentCenter;
+    }
+
+    int distance = std::abs(i - currentCenter);
+    float relValue = value - pow(float(distance) / float(size), width);
+    if (relValue >= 0.f) {
+      (*buffer).at(i) = HSV{hue.getValue(), saturation, std::clamp(relValue,0.f, 1.f)};
+    }
+  }
+
+  return buffer;
+}
+
+void KnightRiderOperation::update(const size_t width, const size_t fps) {
+  if (!isEnabled()) {
+    return;
+  }
+
+  auto stepWitdh = width / fps / float(duration_milliseconds / 1000);
+
+  if (direction == Direction::ASCENDING) {
+    if (currentCenter >= width - 1) {
+      direction = Direction::DESCENDING;
+      return;
+    } else {
+      currentCenter += stepWitdh;
+    }
+  }
+
+  if (direction == Direction::DESCENDING) {
+    if (currentCenter <= 0) {
+      direction = Direction::ASCENDING;
+      return;
+    } else {
+      currentCenter -= stepWitdh;
+    }
+  }
+
+  currentCenter = std::clamp(currentCenter, 0, int(width - 1 ));
+}

src/operations/KnightRider.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "Operation.h"
+
+class KnightRiderOperation : public Operation {
+  enum State {
+    IDLE,
+    RUNNING,
+  } state;
+
+  enum Direction {
+    ASCENDING,
+    DESCENDING,
+  } direction;
+
+  int currentCenter = 0;
+
+  BoundConcreteValue<float> hue;
+  BoundConcreteValue<float> saturation;
+  BoundConcreteValue<float> value;
+
+  BoundConcreteValue<int> duration_milliseconds;
+  BoundConcreteValue<float> width;
+
+  float getShade() const;
+
+ public:
+  KnightRiderOperation(const std::string& name,
+                       std::shared_ptr<VariableStore> store,
+                       YAML::const_iterator begin,
+                       YAML::const_iterator end);
+
+  virtual ~KnightRiderOperation() {}
+
+  virtual Operation::BufferType operator()(Operation::BufferType& buffer);
+
+  virtual void update(const size_t width, const size_t fps);
+};