Gradient  g;
int[]     currG;
boolean   inited;
int[]     buffer;
int       area;

void setup() {
  size(200,200);
  inited=false;
  area=width*height;
  buffer=new int[area];
}

void draw() {
  if (!inited) {
    initColors();
    inited=true;
  }
  currG=g.calcGradient(max(mouseY*5,0),height);
  for(int y=0; y<height; y++) {
    stroke(currG[y]|0xff000000);
    line(0,y,width,y);
  }
}

void initColors() {
  g=new Gradient();
  int pos=0;
  while(pos<2500) {
    g.addColor(pos,(int)random(0xffffff));
    pos+=(int)random(10,100);
  }
}

void mouseReleased() {
  inited=false;
}

class Gradient {
  
  private class GradPoint {
    int  pos;
    int  col;
    GradPoint(int p, int c) {
      pos=p;
      col=c;
    }
  }
  
  private GradPoint[] gradient;
  private int numColors;
  
  Gradient() {
    numColors=0;  
  }
  
  // add a new colour at specified position
  public void addColor(int p, int c) {
    if (numColors==0) {
      gradient=new GradPoint[1];
      gradient[numColors]=new GradPoint(p,c);
      numColors++;
    } else {
      GradPoint[] newGrad = new GradPoint[++numColors];
      System.arraycopy(gradient,0,newGrad,0,numColors-1);
      newGrad[numColors-1]=new GradPoint(p,c);
      gradient=newGrad;
    }
  }
  
  // generic linear interpolation
  int mix(int a,int b, float f) { return (int)(a+(b-a)*f); }
  
  // blend 2 colours
  int blend(int a, int b, float f) {
    return mix(a>>16,b>>16,f)<<16 | mix(a>>8&0xff,b>>8&0xff,f)<<8 | mix(a&0xff,b&0xff,f);
  }
  
  // calculate number of steps of gradient from specified position (only values >0)
  public int[] calcGradient(int pos, int steps) {
    int[] result=new int[steps];
    float imp;
    int first=numColors-1;
    int endPos=pos+steps;
    // find 1st colour needed, clamp start position to positive values only
    pos=(pos>-1) ? pos : 0;
    for(int i=0; i<numColors; i++) {
        if (gradient[i].pos>pos) { first=i-1; i=numColors; }
    }
    float currWidth=(first<numColors-1) ? 1.0f/(float)(gradient[first+1].pos-gradient[first].pos) : 0f;
    int i=0;
    while(pos<endPos) {
      imp=(pos-gradient[first].pos)*currWidth;
      // switch to next colour?
      if (imp>1) {
        first++;
        currWidth=(first<numColors-1) ? 1.0f/(float)(gradient[first+1].pos-gradient[first].pos) : 0f;
        imp=(pos-gradient[first].pos)*currWidth;
      }
      result[i++]=(first<numColors-1) ? blend(gradient[first].col,gradient[first+1].col,imp) : gradient[first].col;
      pos++;
    }
    return result;
  }
}