void display(creature c)
{
  switch(displayMode)
  {
    case 1:
      drawLattice(c.phenotype);      
    break;
    case 2:
      noFill();
      stroke(80,120);
      ellipse(c.phenotype.averagePos,c.phenotype.mostDistant*2);    
      drawCells(c.phenotype);      
    break;
    case 3:
      drawLines(c.phenotype);          
    break;
    case 4:
      drawCells(c.phenotype);    
      blur(1);             
      drawLattice(c.phenotype);        
      blur(1);
      drawLines(c.phenotype);      
    break;
    case 5:
      render(c);
    break;
  }
}
void blur(int tt) {
  for(int ttt = 0; ttt <= tt; ttt++){
    int R,G,B,left,right,top,bottom;
    int c,cl,cr,ct,cb;
    int w1=width-1;
    int h1=height-1;
    int index=0;
    for(int y=0;y<height; y++) {
      top=(y>0) ? -width : h1*width;
      bottom=(y==h1) ? -h1*width : width;
      for(int x=0; x<width; x++) {
        // Wraparound offsets
        left=(x>0) ? -1 : w1;
        right=(x<w1) ? 1 : -w1;
        
        c=pixels[index];
        cl=pixels[left+index];
        cr=pixels[right+index];
        ct=pixels[top+index];
        cb=pixels[bottom+index];
        
        // Calculate the sum of all neighbors
        R=((cl>>16 & 255) + (cr>>16 & 255) + (c>>16 & 255) + (ct>>16 & 255) + (cb>>16 & 255)) / 5;
        G=((cl>>8 & 255) + (cr>>8 & 255) + (c>>8 & 255) + (ct>>8 & 255) + (cb>>8 & 255)) / 5;
        B=((cl & 255) + (cr & 255) + (c & 255) + (ct & 255) + (cb & 255)) / 5;
        pixels[index++]=(R<<16)+(G<<8)+B;
      }
    }    
  }        
}
void ellipse(position p,float d)
{
  ellipse(p.x,p.y,d,d);
}

void drawArrow(position p1,position p2)
{
  position corner=new position(new position(0,0));
  position bLeft=new position(corner.displace(140,4));
  position bRight=new position(corner.displace(220,4));
  float heading=radians(360-getHeading(p1,p2));  
  push();
  line(p1.x,p1.y,p2.x,p2.y);
  translate(p2.x,p2.y);
  rotate(heading);
  beginShape(POLYGON);
  vertex(corner.x,corner.y);
  vertex(bLeft.x,bLeft.y);
  vertex(bRight.x,bRight.y);
  endShape();
  pop();
}

void displayCreatureData(creature c)
{
  float distance=dist(c.lastP,c.p);
  c.distanceTravelled+=distance; 
  fill(150);
  position p=c.p.displace(35,c.currentSize()*.8);
  textFont(uiFont,14);
  text("Distance Travelled: "+nf(c.distanceTravelled,4,1)+"px",p.x,p.y);
  text("  Average Speed: "+nf(c.distanceTravelled/float(timeSteps),2,3)+"px/frm",p.x,p.y+14);  
  text("   Elapsed Time: "+timeSteps+"frms",p.x,p.y+28);    
}

void drawLattice(lattice phen)
{
  noFill();
  float t=phen.tension*200;
  for(int i=0;i<phen.nodes.length;i++)
  {
    //Draw All Lines
    for(int s=0;s<phen.nodes[i].c.output.length;s++)
    {
      float a=255-(dist(phen.nodes[i].p,phen.nodes[phen.nodes[i].c.output[s]].p)/45*255);
      if(a>15)
      {
        stroke(255,255,255,a);
        line(phen.nodes[i].x(),phen.nodes[i].y(),phen.nodes[phen.nodes[i].c.output[s]].x(),phen.nodes[phen.nodes[i].c.output[s]].y());  
      }
    }
    //Draw Collisions
    for(int v=i;v<phen.nodes.length;v++)
    {
      boolean doCollide=true;              
      if(dist(phen.nodes[i].p,phen.nodes[v].p)<phen.collisionDistance)
      {
        for(int out=0;out<phen.nodes[i].c.output.length;out++)
        {
          if(phen.nodes[i].c.output[out]==v)
          {
            doCollide=false;
            break;                    
          }
        }              
        for(int in=0;in<phen.nodes[i].c.input.length;in++)
        {
          if(phen.nodes[i].c.input[in]==v)
          {
            doCollide=false;              
            break;
          }
        }      
        if(doCollide)
        {
          float a=150-(dist(phen.nodes[i].p,phen.nodes[v].p)/150*255);        
          if(a>120)
          {
            stroke(150+a,125,115,a);
            line(phen.nodes[i].x(),phen.nodes[i].y(),phen.nodes[v].x(),phen.nodes[v].y());
          }
        }
      }
    }
    //Draw the cell ellipse
    float vel=phen.nodes[i].velocity.m;
    stroke(222,222,222+t);        
    ellipse(phen.nodes[i].x(),phen.nodes[i].y(),5+constrain((vel*1.5),0,4),5+constrain((vel*1.5),0,4));
  }
}

void drawCells(lattice phen)
{
  noFill();
  stroke(50,120);

  for(int i=0;i<phen.nodes.length;i++)
  {   
    noFill();      
    if(phen.nodes[i].n.firing)
    {
      stroke(255);
      ellipse(phen.nodes[i].p,13);      
    }
    else
    {
      noStroke();
      float ra=(phen.nodes[i].n.accumulated+1)/2;
      ra=constrain(ra,0,1);
      float rt=(phen.nodes[i].n.threshold+1)/2;
      ra=constrain(ra,0,1);        
      fill(150,180,250,ra*200);        
      ellipse(phen.nodes[i].p,ra*10);
      
      fill(255,50,50,rt*200); 
      ellipse(phen.nodes[i].p,rt*8);                
      noFill();
    
      if(phen.nodes[i].isNeuron&&!phen.nodes[i].isLightSensor)        
        stroke(80,120,200);
      else
      if(phen.nodes[i].isMuscle)
        stroke(220,160,80);
      else      
      if(phen.nodes[i].isLightSensor)
        stroke(150,220,70);
      else
        stroke(90);
      ellipse(phen.nodes[i].p,12);      

    }
    if(phen.nodes[i].isNeuron)
    {
      int le=phen.nodes[i].n.output.length;
      for(int o=0;o<le;o++)
      {
        int id=phen.nodes[i].n.output[o].n.id;      
        vector vec=new vector(phen.nodes[i].p,phen.nodes[id].p);
        vec.m*=.8;  
        if(phen.nodes[i].n.firing)
        {
          stroke(240,0,0,120);
          fill(240,0,0,120);                 
          position ep=vec.ep();
          line(vec.p.x,vec.p.y,ep.x,ep.y);
        }
        else
        {
          stroke(220,240,225,90);
          fill(220,240,225,90);                            
          drawArrow(vec.p,vec.ep());              
        }    
      }        
    }
    if(phen.nodes[i].isMuscle)
    {  
      stroke(220,35,15,150);          
      position p1=phen.nodes[i].p;    
      int lo=phen.nodes[i].c.output.length;          
      for(int o=0;o<lo;o++)
      {
        int index=phen.nodes[i].c.output[o];
        if(phen.nodes[index].isMuscle)
        {
          position p2=phen.nodes[index].p;
          line(p1.x,p1.y,p2.x,p2.y);  
        }
      }
      int li=phen.nodes[i].c.input.length;    
      for(int in=0;in<li;in++)
      {
        int index=phen.nodes[i].c.input[in];      
        if(phen.nodes[index].isMuscle)
        {
          position p2=phen.nodes[index].p;
          line(p1.x,p1.y,p2.x,p2.y);  
        }
      }      
    }
  }
}
void drawLines(lattice phen)
{
  noFill();
  float t=phen.tension*200;
  for(int i=0;i<phen.nodes.length;i++)
  {
    for(int s=0;s<phen.nodes[i].c.output.length;s++)
    {
      float a=255-(dist(phen.nodes[i].p,phen.nodes[phen.nodes[i].c.output[s]].p)/20*255);
      stroke(220+a/5,220+a/5,20+t,a);
      line(phen.nodes[i].x(),phen.nodes[i].y(),phen.nodes[phen.nodes[i].c.output[s]].x(),phen.nodes[phen.nodes[i].c.output[s]].y());  
//      noFill();
//      ellipse(phen.nodes[i].p,20);    
    }
  }  
}
/*
void text(String buff,float x,float y)
{
  push();
  translate(x,y);
  for(int i=0;i<buff.length();i++)
  {
    char k = buff.charAt(i);
    translate(uiFont.width(k)*15,0);
//    translate(-f.width(k)*25,0);
    scale(1);
    text(k,0,0);
  }
  pop();
}
*/