add knightrider

Author: wind0r

config.yml

@@ -55,6 +55,11 @@ operations:
     type: rotate
     params:
       step_width: 50
+  knightrider:
+    type: knightrider
+    params:
+      duration: 33
+      width: 0.3
   example-lua:
     type: lua
     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,81 @@
+#include "KnightRider.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+
+
+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),
+      time_passed(0),
+      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, 33)),
+      width(name + "/width",
+                  Operation::FLOAT,
+                  store,
+                  getValueByKey<float>("width", begin, end, 0.1f)) {}
+
+Operation::BufferType KnightRiderOperation::operator()(
+    Operation::BufferType& buffer) {
+  if (state == State::IDLE)
+    return buffer;
+
+  int size = (*buffer).size();
+
+  for (int i = 0; i < size; i++) {
+    int distance = std::abs(i - currentCenter);
+    float relValue = value - pow(float(distance) / float(size), width);
+    (*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) {
+  if (!isEnabled()) {
+    state = State::IDLE;
+    return;
+  }
+
+  if (time_measurement.measure() < duration_milliseconds)
+    return;
+
+  state = State::RUNNING;
+  time_measurement.reset();
+
+  if (direction == Direction::ASCENDING) {
+    if (currentCenter >= width) {
+      direction = Direction::DESCENDING;
+      return;
+    } else {
+      currentCenter++;
+    }
+  }
+
+  if (direction == Direction::DESCENDING) {
+    if (currentCenter <= 0) {
+      direction = Direction::ASCENDING;
+      return;
+    } else {
+      currentCenter--;
+    }
+  }
+}

src/operations/KnightRider.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "Operation.h"
+
+class KnightRiderOperation : public Operation {
+  enum State {
+    IDLE,
+    RUNNING,
+  } state;
+
+  enum Direction {
+    ASCENDING,
+    DESCENDING,
+  } direction;
+
+  inline const char* toString(State s) {
+    switch (s) {
+      case State::IDLE:
+        return "IDLE";
+      case State::RUNNING:
+        return "RUNNING";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  int64_t time_passed;
+  int currentCenter;
+
+  MeasureTime<> time_measurement;
+
+  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);
+};