simulator.h

Go to the documentation of this file.

 
#ifndef SIMULATOR_H
#define SIMULATOR_H
 
#include <cstring>
#include <iostream>
 
// include this first
#include "src/system/global.h"
 
#include "parameter_parser.h"
#include "simulator_state.h"
 
// see LMBD_LAMP_TYPE__${UPPER_SIM_NAME} hard-coded in simulator/Makefile
#include "src/user/constants.h"
 
#include <SFML/Graphics.hpp>
#include <SFML/Graphics/Color.hpp>
#include <SFML/System/Time.hpp>
#include <SFML/Window/Keyboard.hpp>
 
// #define LMBD_DEBUG_SIMU_REALCOLORS
 
namespace simulator {
// (_LampTy from simulator_state.h)
constexpr int ledW = _LampTy::maxWidth;
constexpr int ledH = _LampTy::maxOverflowHeight;
constexpr int ledCount = _LampTy::ledCount;
 
constexpr float fLedW = _LampTy::maxWidthFloat;
constexpr float fResidueW = 1 / (2 * fLedW - 2 * floor(fLedW) - 1);
} // namespace simulator
 
#include "src/user/functions.h"
#include "src/system/utils/utils.h"
 
#include "simulator/include/hardware_influencer.h"
// handle simulation of voltage and current in the system
#include "simulator/electrical/electrical_mock.cpp"
 
#include <thread>
 
namespace simulator {
 
//
// simulator core loop
//
 
template<typename T> struct simulator
{
  static constexpr uint screenWidth = 1920;
  static constexpr uint screenHeight = 1080;
  static constexpr char title[] = "lampda simulator";
 
  static constexpr uint brightnessWidth = 480;
 
  static int run()
  {
    T simu;
    sf::Clock time;
 
    // brightness tracker
    std::array<uint16_t, brightnessWidth> brightnessTracker {};
    std::array<sf::RectangleShape, brightnessWidth> dots;
 
    // matrix shift
    int fakeXorigin = 0;
    int fakeXend = 0;
 
    // pixel shapes
    std::array<sf::RectangleShape, _LampTy::ledCount> shapes;
 
    // init font
    sf::Font font;
    bool enableFont = false;
    bool enableText = false;
    if (font.loadFromFile("simulator/resources/DejaVuSansMono.ttf"))
    {
      enableFont = true;
    }
    else
    {
      fprintf(stderr, "DejaVuSansMono.ttf not found, disabling text...");
    }
 
    // render window
    sf::RenderWindow window(sf::VideoMode({screenWidth, screenHeight}), title);
 
    sf::CircleShape buttonMask(simu.buttonSize);
    sf::CircleShape indicator(simu.buttonSize + simu.buttonMargin);
    buttonMask.setFillColor(sf::Color::Black);
 
    sf::Vector2<int> mousePos = sf::Mouse::getPosition(window);
    const float indCoordX = simu.buttonLeftPos;
    const float indCoordY = (simu.ledSizePx + simu.ledPaddingPx) * (ledH + 3);
 
    // TODO: #156 move mock-specific parts to another process
    // ======================================================
 
    // mock run the threads (do not give each subprocess a thread)
    mock_registers::shouldStopThreads = false;
 
    // load initial values
    read_and_update_parameters();
    // start electrical simulation,
    start_electrical_mock();
 
    // force init of time clock
    time_mocks::reset();
 
    // Main program setup
    ::lampda::main_setup();
 
    bool lostFocus = false;
 
    // =================================================
 
    // reference to global state
    auto& state = globals::state;
 
    uint64_t skipframe = 0;
    while (window.isOpen())
    {
      uint64_t mouseClick = 0;
 
      mousePos = sf::Mouse::getPosition(window);
      enableText = enableFont && sf::Mouse::isButtonPressed(sf::Mouse::Button::Left);
      enableText |= state.verbose;
 
      // read events, prevent windows lockup
      sf::Event event;
      while (window.pollEvent(event))
      {
        if (event.type == sf::Event::Closed)
        {
          window.close();
          break;
        }
        else if (event.type == sf::Event::LostFocus)
          lostFocus = true;
        else if (event.type == sf::Event::GainedFocus)
          lostFocus = false;
 
        if (not lostFocus)
        {
          if (event.type == sf::Event::KeyPressed)
          {
            auto kpressed = event.key.code;
            switch (kpressed)
            {
              default:
                state.lastKeyPressed = 0;
                break;
              case sf::Keyboard::Key::P: // p == pause
                state.lastKeyPressed = 'p';
                break;
              case sf::Keyboard::Key::V: // v == verbose
                state.lastKeyPressed = 'v';
                break;
              case sf::Keyboard::Key::T: // t == tick +pause
                state.lastKeyPressed = 't';
                break;
              case sf::Keyboard::Key::H: // h == higher speed
                state.lastKeyPressed = 'h';
                break;
              case sf::Keyboard::Key::G: // g == glower speeds
                state.lastKeyPressed = 'g';
                break;
              case sf::Keyboard::Key::J: // j == shift matrix left
                state.lastKeyPressed = 'j';
                break;
              case sf::Keyboard::Key::K: // k == shift matrix right
                state.lastKeyPressed = 'k';
                break;
              case sf::Keyboard::Key::D:
                state.lastKeyPressed = 'd';
                break;
              case sf::Keyboard::Key::U:
                state.lastKeyPressed = 'u';
                break;
              case sf::Keyboard::Key::I:
                state.lastKeyPressed = 'i';
                break;
              case sf::Keyboard::Key::R:
                state.lastKeyPressed = 'r';
                break;
              case sf::Keyboard::Key::C:
                state.lastKeyPressed = 'c';
                break;
              case sf::Keyboard::Key::Q:
                state.lastKeyPressed = 'q';
                break;
            }
 
            break;
          }
          else if (event.type == sf::Event::KeyReleased)
          {
            // tick forward (once) and pause
            if (state.lastKeyPressed == 't')
            {
              state.paused = false;
              state.tickAndPause = 2;
            }
 
            // pause event
            if (state.lastKeyPressed == 'p')
            {
              state.paused = !state.paused;
            }
 
            // verbose event
            if (state.lastKeyPressed == 'v')
            {
              state.verbose = !state.verbose;
            }
 
            // slower simulation
            if (state.lastKeyPressed == 'g')
            {
              if (state.slowTimeFactor > 1.50f)
              {
                state.slowTimeFactor *= 0.95f;
              }
              else if (state.slowTimeFactor > 1.0f)
              {
                state.slowTimeFactor = ceil(state.slowTimeFactor * 20 - 1) / 20;
              }
              else
              {
                state.slowTimeFactor = std::max<float>(0.1f, state.slowTimeFactor - 0.05f);
              }
              fprintf(stderr, "slower %f\n", state.slowTimeFactor);
            }
 
            // faster simulation
            if (state.lastKeyPressed == 'h')
            {
              if (state.slowTimeFactor > 1.20f)
              {
                state.slowTimeFactor *= 1.05f;
              }
              else if (state.slowTimeFactor > 1.0f)
              {
                state.slowTimeFactor = ceil(state.slowTimeFactor * 20 + 1) / 20;
              }
              else
              {
                state.slowTimeFactor += 0.05f;
              }
              fprintf(stderr, "faster %f\n", state.slowTimeFactor);
            }
 
            // shift forward XY display
            if (state.lastKeyPressed == 'k')
            {
              fakeXorigin += 1;
              if (fakeXorigin > ledW - 1)
                fakeXorigin = 0;
              fakeXend = std::max<int>(fakeXorigin - std::min<int>(4, ledW - 1 - fakeXorigin), 0);
            }
 
            // shift backward XY display
            if (state.lastKeyPressed == 'j')
            {
              fakeXorigin -= 1;
              if (fakeXorigin < 0)
                fakeXorigin = ledW - 1;
              fakeXend = std::max<int>(fakeXorigin - std::min<int>(4, ledW - 1 - fakeXorigin), 0);
            }
 
            // reset key pressed
            state.lastKeyPressed = 0;
            break;
          }
          else if (event.type == sf::Event::MouseButtonPressed)
          {
            float dx = indCoordX - mousePos.x + simu.buttonSize;
            float dy = indCoordY - mousePos.y + simu.buttonSize;
            float norm = simu.buttonSize;
 
            if (dx * dx + dy * dy < norm * norm)
            {
              mouseClick += 3;
            }
            break;
          }
        }
      }
 
      // update simulator global state
      state.isButtonPressed = (not lostFocus) and sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space);
      if (mouseClick > 0)
      {
        mouseClick -= 1;
        state.isButtonPressed = true;
      }
 
      if (state.tickAndPause > 0)
      {
        if (state.tickAndPause == 1)
        {
          state.paused = true;
        }
        state.tickAndPause -= 1;
      }
 
      // TODO: #156 move mock-specific parts to another process
      // ======================================================
 
      if (!state.paused)
      {
        // deep sleep, exit
        if (mock_registers::isDeepSleep)
        {
          // close all threads
          window.close();
          break;
        }
 
        // update simu parameters
        read_and_update_parameters();
        // update the callbacks of the gpios (simulate interrupts)
        mock_gpios::update_callbacks();
 
        // main program loop
        ::lampda::main_loop(mock_registers::addedAlgoDelay);
      }
 
      const bool isOutputEnabled = is_output_enabled();
      if constexpr (_LampTy::flavor == ::lampda::modes::hardware::LampTypes::indexable)
      {
#ifdef LMBD_LAMP_TYPE__INDEXABLE
        // brightness on the indexale lamp
        using curve_t = ::lampda::common::curves::LinearCurve<::lampda::brightness_t, uint8_t>;
        static curve_t brightnessCurve({curve_t::point_t {0, ::lampda::minimumAllowedBrightness_8},
                                        curve_t::point_t {::lampda::brightness::absoluteMaximumBrightness, 255}});
        state.brightness = brightnessCurve.sample(::lampda::logic::brightness::get_brightness());
 
        const bool isVoltageHighEnough = mock_electrical::outputVoltage > 11.5;
        for (size_t I = 0; I < _LampTy::ledCount; ++I)
        {
          state.colorBuffer[I] =
                  isOutputEnabled ?
                          (isVoltageHighEnough ? ::lampda::user::_private::strip.getRawPixelColor(I) : 0xffffff) :
                          0;
        }
#endif
      }
      else
      {
        state.brightness =
                (::lampda::logic::brightness::get_brightness() * 255) / ::lampda::brightness::absoluteMaximumBrightness;
 
        for (size_t I = 0; I < _LampTy::ledCount; ++I)
          state.colorBuffer[I] = isOutputEnabled ? 0xffff00 : 0;
      }
 
      state.indicatorColor = mock_indicator::get_color();
      // ======================================================
 
      const float ledSz = simu.ledSizePx;
      const auto ledPadSz = simu.ledPaddingPx + simu.ledSizePx;
      const auto ledOffset = ledSz / _LampTy::shiftPeriod;
 
      const float Xbase = _LampTy::extraShiftTotal > 0 ? 0 : -_LampTy::extraShiftTotal;
      const float Xextra = _LampTy::extraShiftTotal < 0 ? 0 : _LampTy::extraShiftTotal;
 
      // draw slightly grey background to hightlight turned off LEDs
      window.clear(sf::Color(13, 12, 11));
 
      for (int Ypos = 0; Ypos < ledH; ++Ypos)
      {
        int realRowSize = ledW;
        if (_LampTy::allDeltaResiduesY[Ypos])
          realRowSize += 1;
 
        for (int fXpos = -fakeXorigin; fXpos < realRowSize - fakeXend; ++fXpos)
        {
          int Yoff = 0;
          int Xoff = 0;
 
          int Xpos = fXpos;
          if (fXpos < 0)
          {
            Xpos = realRowSize + fXpos;
            Yoff = 1;
 
            if (_LampTy::allDeltaResiduesY[Ypos])
              Xoff = 1;
          }
 
          size_t I = ::lampda::modes::to_strip(Xpos, Ypos);
          auto& shape = shapes[I];
 
          auto realPos = ::lampda::modes::strip_to_XY(I);
          if (realPos.x != Xpos || realPos.y != Ypos)
            continue;
 
          shape.setSize({ledSz, ledSz});
 
          int rXpos = fXpos + fakeXorigin + Xoff;
          int rYpos = Ypos + Yoff;
          int shiftR = _LampTy::extraShiftResiduesY[Ypos];
          int shiftL = Ypos + shiftR + 1;
 
          if (_LampTy::shiftResidue == 1 && _LampTy::shiftPerTurn < 0.1)
            shiftR = 0;
 
          float shapeX = ledSz + rXpos * ledPadSz;
          shapeX += ledOffset * Xbase;
          shapeX += ledOffset * (shiftL % _LampTy::shiftPeriod);
          shapeX -= (ledOffset - simu.ledPaddingPx / 2) * (Yoff - shiftR);
          shapeX -= Xoff * simu.ledPaddingPx;
 
          // make the origin more obvious
          if (fXpos >= 0)
            shapeX += simu.ledPaddingPx;
 
          float shapeY = rYpos * ledPadSz;
          shape.setPosition({shapeX, shapeY});
 
          const uint32_t color = state.colorBuffer[I];
          float b = (color & 0xff);
          float g = ((color >> 8) & 0xff);
          float r = ((color >> 16) & 0xff);
 
#ifndef LMBD_DEBUG_SIMU_REALCOLORS
          if (state.brightness != 255)
          {
            // scale by brightness
            r = (uint16_t(r) * state.brightness + state.brightness) >> 8;
            g = (uint16_t(g) * state.brightness + state.brightness) >> 8;
            b = (uint16_t(b) * state.brightness + state.brightness) >> 8;
          }
#endif
 
          shape.setFillColor(sf::Color(r, g, b));
          window.draw(shape);
 
          // display text information if mouse is pressed
          if (enableText)
          {
            int MouseYpos = mousePos.y;
            int MouseXpos = mousePos.x;
 
            auto shapeXY = shape.getPosition();
            float dx = shapeXY.x + ledSz / 2 - MouseXpos;
            float dy = shapeXY.y + ledSz / 2 - MouseYpos;
 
            // all shapes too far from cursor, does not display info
            if (abs(2 * dx) > ledPadSz || abs(2 * dy) > ledPadSz)
              continue;
 
            // display (X,Y) on bottom-right
            float largestX = ledSz + (ledW + 1 + fakeXorigin - fakeXend) * ledPadSz + ledOffset * (Xextra + Xbase);
            float largestY = (ledH + Yoff) * ledPadSz + 8;
            {
              auto str = "(" + std::to_string(Xpos) + ", " + std::to_string(Ypos) + ")";
 
              sf::Text text(str, font, 12);
              sf::Vector2f where(largestX, largestY);
              text.setPosition(where);
              window.draw(text);
            }
 
            // display Ypos on the right
            {
              auto str = std::to_string(Ypos);
              if (_LampTy::allDeltaResiduesY[Ypos])
                str += " *";
 
              sf::Text text(str, font, 12);
              sf::Vector2f where(largestX, shapeXY.y + ledSz / 4);
              text.setPosition(where);
              window.draw(text);
            }
 
            // display Xpos on the bottom
            {
              auto str = std::to_string(Xpos);
              if (Xpos == ledW)
                str += " *";
 
              sf::Text text(str, font, 12);
              sf::Vector2f where(shapeXY.x, largestY);
              text.setPosition(where);
              window.draw(text);
            }
 
            // display misc info next to button
            {
              auto str = "(" + std::to_string(int(r)) + ", ";
              str += std::to_string(int(g)) + ", ";
              str += std::to_string(int(b)) + ")";
              str += ", " + std::to_string(I);
 
              sf::Text text(str, font, 12);
              sf::Vector2f where(indCoordX + simu.buttonSize * 3, indCoordY - 24.f);
              text.setPosition(where);
              window.draw(text);
 
              // (avoid superposed text)
              enableText = false;
            }
          }
        }
      }
 
      // display the indicator button
      const uint32_t indicatorColor = state.indicatorColor;
      float b = (indicatorColor & 0xff);
      float g = ((indicatorColor >> 8) & 0xff);
      float r = ((indicatorColor >> 16) & 0xff);
      indicator.setFillColor(sf::Color(r, g, b));
      indicator.setPosition({indCoordX, indCoordY});
      buttonMask.setPosition({indCoordX + simu.buttonMargin, indCoordY + simu.buttonMargin});
      window.draw(indicator);
      window.draw(buttonMask);
 
      // track brightness & display dot curve
      float now = (time.getElapsedTime().asMilliseconds() * simu.fps) / 1000.f;
      uint32_t trackerPos = now / simu.brightnessRate;
 
      trackerPos = trackerPos % brightnessTracker.size();
      brightnessTracker[trackerPos] = state.brightness;
      brightnessTracker[(trackerPos + 1) % brightnessTracker.size()] = 0;
 
      float xDotsOrigin = indCoordX + simu.buttonSize * 2 + simu.buttonMargin * 2 + 16.f;
      float yDotsOrigin = indCoordY + simu.brightnessScale;
 
      for (size_t I = 0; I < brightnessTracker.size(); ++I)
      {
        auto& dot = dots[I];
 
        float v = (brightnessTracker[I] * simu.brightnessScale) / 256;
        float x = xDotsOrigin + I;
        float y = yDotsOrigin - v;
        dot.setSize({1, 1});
        dot.setPosition({x, y});
        dot.setFillColor(sf::Color(0, 0xff, 0));
        window.draw(dot);
      }
 
      // draw window
      window.display();
    }
 
    stop_electrical_mock();
 
    return 0;
  }
};
 
} // namespace simulator
 
#endif