Sliders, sliders, sliders, and did I say sliders?

I realized a good example of all the ways to use a slider is sorely needed.

So I’ll write up a good reference pattern that has a pile of sliders, well commented for each example (and likely each will have alternative configs commented out)

Binary, integer, logarithmic, easing, resetting/triggering, and more.

Ok, code is here… still in progress. Currently mildly assumes you have a 16x16 matrix, but should work for anything like a 50 pixel string too…

Slider Demos v0.5
// these are examples of how sliders can do a lot of things

// The value of the slider - I use n here, you'll also see v used, whatever it is,
// it's the value 0..1 passed from the slider, into the function.

// binary
export var binary = 1
export function sliderBinaryOffOn(n){
    binary = floor(n+.5)
    // by adding .5, we have the shift from off to on in the middle
    // without it, it'll require going all of the way to the right
    // if you want to be reversed (1 to 0), subtract from 1 (= 1-)
    // you can also use round(), without the +.5

// integer
export var integer = 1
export var integermax = 10
export function sliderIntegers_1_10(n){
    integer = min(integermax,round(n*integermax+.5))
    // without the .5, it'll do 0-10
    // the min prevents it going to 11, unless you are in Spinal Tap.
    // And yes, you _could_ just use the same code as below, from A-B, with a round or floor

// floating value between A and B smoothly
export var floating = 31
export var floatingmin = 16
export var floatingmax = 31
export function sliderfloating_16_31(n){
    floating = floatingmin + (floatingmax - floatingmin) * n

// easing
// this is a truly basic example, see 
// for more easing options... this is just to show that easing in a slider is useful
export var easing = 32
export var easingmin = 32
export var easingmax = 42
export function slidereasing_32_42(n){
    easing = easingmin + (easingmax - easingmin) * n * n * n
    // by multipling n * n * n, that's an easeInCubic, so it's very sensitive on one end, and very fast on the other
    // you could use any easing here though.
    // notice how this is the same code as the floating, but with an easing component.

// logarithmic
// So most of the above are using simple scales... 0-10, A-B, even the easing just curves slower at one end.
// But what if you want to slide from very small values (.01 let's say) to very large values (100)
// If you do a simple linear scale from 0 to 100, it'll be very hard to pick very small values,
// but much easier to pick big ones. Easing could help here, but let's try a different answer:
// Using log() and exp(), we can put 1 in the middle of the range, for example, and have the left half be tiny
//  this is hard to show via an led based slider.  I'll try and come up with a good demo for this.
export var logmin = log(.01);
export var logmax = log(100);
export var logscalefactor = 1
export function sliderLogScale(n){
  logscalefactor = exp(logmin + (logmax-logmin)*n);

// resetting/triggering
// This is an example of having something reset or change, when you move the slider
// In this case, speed starts at 20, and quickly drops to 2, and while it does, the rainbow speeds up
// Once it hits 2, it stays there.  We want a way to reset the value of speed back to 20.
// the trick: save your current value, and then compare it after you involve the new value.
// if it's different, you're in the moment where you slid the slider, so reset now.
// You could also just look for a 0 or 1, meaning you slide all the way to one side, and reset.
//  But what happens if you leave the slider there?  Keeps resetting.  This is a one time reset.
export var speed = 20
export var resetvalue = 1
export var resetvalue_old = 1
export function sliderSpeedReset(n){
  resetvalue_old = resetvalue
  resetvalue = n;
  if (resetvalue_old != resetvalue){
    speed = 20; 

export function beforeRender(delta) {
  t1 = time(speed)
  speed = max(speed - 0.01,2)

export function render(index) {
  if (index == integer || index == floor(floating) || index == floor(easing) ){
  } else {
    h = t1 + index/pixelCount
    s = 1
    v = 1 * binary
    hsv(h, s, v)
1 Like