PaintVuMidNotesFade()

void Painter::PaintVuMidNotesFade ( uint32_t delta_ms, const KeyboardState & keyboard, const int * led_column_table, int led_column_table_length, LedRopeInterface * led_rope )

staticprivate

Definition at line 228 of file Painter.cpp.

                                                              {
  struct DrawPoints {
    int n_black0;
    int n_fade0;
    int n_fill;
    int n_fade1;
    int n_black1;
    float fade_factor;  // 0->1.0
 
    float SumBrightness() const {
      float out = 0;
      out += n_fill;
      out += (fade_factor * n_fade0);
      out += (fade_factor * n_fade1);
      return out;
    }
  };
 
  // Generator for the DrawPoints struct above.
  //  n_led: How many led's there are in total.
  //  factor: 0->1, indicates % of led's "on".
  struct F {
    static DrawPoints Generate(int n_led, float factor) {
      DrawPoints out;
      memset(&out, 0, sizeof(out));
      if (n_led == 0 || factor == 0.0f) {
        out.n_black0 = n_led;
        return out;
      }
      const int is_odd = (n_led % 2);
      const int n_half_lights = n_led / 2 + is_odd;
      const float f_half_fill = n_half_lights * factor;
      const int n_half_fill = static_cast<int>(f_half_fill);  // Truncates float.
      
      float fade_pix_perc = f_half_fill - static_cast<float>(n_half_fill);
      int n_fade_pix = fade_pix_perc < 1.0f;
      if (n_half_fill == 0) {
        n_fade_pix = 1;
      }
      int n_half_black = n_half_lights - n_half_fill - n_fade_pix;
      
      int n_fill_pix = 0;
      if (n_half_fill > 0) {
        n_fill_pix = n_half_fill * 2 + (is_odd ? -1 : 0);  
      }
      
      out.n_black0 = n_half_black;
      out.n_fade0 = n_fade_pix;
      out.n_fill = n_fill_pix;
      out.n_fade1 = n_fade_pix;
      if (!n_fill_pix && is_odd) {
        out.n_fade1 = 0;
      }
      out.n_black1 = n_half_black;
      out.fade_factor = fade_pix_perc;
      return out;
    }
 };
                                  
 
 led_rope->RawBeginDraw();
                           
 for (int i = 0; i < led_column_table_length; ++i) {
    const Key& key = keyboard.keys_[i];
 
    float active_lights_factor = key.IntensityFactor();
 
    //if (key.curr_color_.v_ <= 0.f) {
    //  active_lights_factor = 0.0;
    //}
 
    const int n_led = led_column_table[i];
 
    if (active_lights_factor > 0.0f) {
      DrawPoints dp = F::Generate(n_led, active_lights_factor);
      
      ColorHSV hsv = key.curr_color_;
      hsv.v_ = 1.0;
      Color3i color = hsv.ToRGB();
      // Now figure out optional fade color
      Color3i fade_col;
      ColorHSV c = key.curr_color_;
      c.v_ = dp.fade_factor;
      fade_col = c.ToRGB();
      
      // Output to graphics.
      led_rope->RawDrawPixels(Color3i::Black(), dp.n_black0);
      led_rope->RawDrawPixels(fade_col, dp.n_fade0);
      led_rope->RawDrawPixels(color, dp.n_fill);
      led_rope->RawDrawPixels(fade_col, dp.n_fade1);
      led_rope->RawDrawPixels(Color3i::Black(), dp.n_black1);
 
#ifdef DEBUG_PAINTER
      if (active_lights_factor > 0.0) {
        int total_lights_on = dp.SumBrightness();
        //dprint("total_lights_on: "); dprint(total_lights_on);
        //dprint(", total lights written: "); dprintln(total_lights_on + dp.n_black0 + dp.n_black1);
 
        //float total = (dp.n_fade0 * dp.fade_factor) + (dp.n_fade1 * dp.fade_factor) + static_cast<float>(dp.n_fill);
        #define P(X) dprint(", "#X ": "); dprint(X);
 
        //dprint("active_lights_factor: "); dprintln(active_lights_factor);
 
        //P(dp.n_black0); P(dp.n_fade0); P(dp.n_fill); P(dp.n_fade1); P(dp.n_black1); P(dp.fade_factor);
        P(total_lights_on);
        P(active_lights_factor);
        //P(total);
        dprintln("");
      }
#endif
    } else {
      led_rope->RawDrawPixels(Color3i::Black(), n_led);
    }
 
 
 
  }
 
  
  led_rope->RawCommitDraw();
}

References Color3i::Black(), Key::curr_color_, dprintln, Key::IntensityFactor(), KeyboardState::keys_, P, LedRopeInterface::RawBeginDraw(), LedRopeInterface::RawCommitDraw(), LedRopeInterface::RawDrawPixels(), ColorHSV::ToRGB(), and ColorHSV::v_.

Referenced by Paint().

Here is the call graph for this function:

Here is the caller graph for this function: