{ C U R L Y }

made in Processing

int cx = 300; 
int cy = 300;
int angle = 0;
int mag = 100;
float n_ang;

void setup(){ size(600, 600); }

void draw()
{
  n_ang = radians(angle);
  rect(cx, cy, sin(n_ang)*mag, cos(n_ang)*mag );
  delay(20);  
  angle+=4;
  mag+=random(-10,10);
}

  


   
float n_x,n_y,xx,yy = 300;

void setup(){ size(600,600); }

void draw()
{
  n_x = random(100,500);
  n_y = random(100,500);  
  line(  xx,yy,n_x,n_y );  
  xx = n_x;
  yy = n_y;  
  rect(0, 0, 600, 600);
  fill(255, 20);
}

  


   
float cx, cy;
float angle = 0;
boolean start = false;

void setup(){ size(600,600); }

void draw()
{
  angle+=5;
  background(255);
  cx = 300 + sin(radians(angle))*50; 
  cy = 300 +  cos(radians(angle))*50;
  line(cx, 0, cx, 600);
  line(cx+10, 0, cx+10, 600);
  line(cx-10, 0, cx-10, 600);
  line(100, cy-100, 500, cy-100);
  line(100, cy+100, 500, cy+100);
  fill(255,0,0);  
  ellipse( cx+(500-cx)/2, 300,  14,14  );
}

  


   
float[] angles = new float[3];
float[] angles_add = {1,-5,10};
float[] mag = {70,50,30};
float[] x = new float[3];
float[] y = new float[3];
float addx,addy;

void setup()
{
  size(600,600);  
  for(int i=0; i<3; i++ ){ angles[i] = 0; }  
}

void draw()
{   
  strokeWeight(0);
  fill(255, 250 );
  rect(0, 0, 600, 600);
  
  for(int i=0; i<3; i++ ){ angles[i] += angles_add[i]; }
  
  for(int i=0; i<3; i++ )
  {
    if(  i==0 )
    { 
      addx = 300;
      addy = 300;
    }
    else
    {
      addx = x[i-1];
      addy = y[i-1];
    }
    
    x[i] = sin(radians(angles[i]))*mag[i] + addx;
    y[i] = cos(radians(angles[i]))*mag[i] + addy;    
    ellipse( x[i], y[i] , 10,10 );
  }
}

  


   
int i = 0;
float pos_y = random(100,500);
int n_blocks = int(random(5,15));

void setup()
{
  size(600,600);
  background(255);
}

void draw()
{
    fill(255, 4 );
    rect(0, 0, 600, 600);    
    rect(  50+20*i, pos_y, 20,20  );
    delay(10);
    i+=1;    
    if(i>n_blocks)
    {
      i=0;
      pos_y = random(100,500);
      n_blocks = int(random(5,15));
    }  
}
  


   
int hight = 300;

void setup()
{
  size(600,600);
  background(255);
}

void draw()
{
  strokeWeight(0);
  fill(255, 10);
  rect(0, 0, 600, 600);
  strokeWeight(10);
  line( hight, 300, hight, hight );  
  hight += random(-10,11);
}
  


   
int angle = 180;
int direction = 1;
float xx,yy;

void setup(){ size(400,400); strokeWeight(1); }

void draw()
{
  fill(255, 255 );
  rect(0, 0, 400, 400);  
  xx = sin(radians(angle))*50+100;
  yy = cos(radians(angle))*50+150;
  for(int i=0;i<3; i++){ rect( xx+i*10, xx, yy, yy); }
  for(int i=0;i<3; i++){ ellipse( xx+50+i*15, xx+angle%360, 9, 9); }
  angle += direction;  
}
  


   
float x_pos = 0;

void setup(){ size(600, 400); }

void draw()
{  
  line(x_pos,0,x_pos,400);  
  ellipse(x_pos,sin(x_pos)*10+200,10,10);
  rect(0, 0, 600, 600);
  fill(255, 30);  
  delay(20);  
  x_pos += 20;
  if(x_pos>2000){x_pos=0;}
}
  


   
int angle = 0; 
float pos_x,pos_y;
void setup(){ size(380, 380); }

void draw()
{
  background(255);  
  pos_x = sin(radians(angle))*20;
  pos_y = cos(radians(angle))*20;    
  for(int x=0; x<20; x++){
    for(int y=0; y<20; y++){
      line( x*20,y*20, pos_x+x*20,pos_y+y*20  );
    }
  }  
  angle += 1;
}
  


   
float[] angle = {0,90,180,270};
float tmp_angle,pos_y,pos_x;
void setup(){ size(380, 380); }

void draw()
{
  background(255);        
  for(int x=0; x<20; x++){
    for(int y=0; y<20; y++){      
      tmp_angle = angle[int(random(0,4))];
      pos_x = sin(radians(tmp_angle))*20;
      pos_y = cos(radians(tmp_angle))*20;      
      line( x*20,y*20, pos_x+x*20,pos_y+y*20  );
    }
  }  
  delay(500);
}
  


   
int a = 0;
float[] angle = {0,90,180,270};
float tmp_angle,pos_y,pos_x;
void setup(){ size(380, 380); }

void draw()
{
  background(255);  
  for(int x=0; x<20; x++){
    for(int y=0; y<20; y++){      
      tmp_angle =  angle[(x*y*a)%4];
      pos_x = sin(radians(tmp_angle))*20;
      pos_y = cos(radians(tmp_angle))*20;      
      line( x*20,y*20, pos_x+x*20,pos_y+y*20  );
    }
  }  
  delay(500);
  a+=1;
}
  


   
float theta,gamma,x;
void setup() {  size(400, 400); }

void draw() {
  fill(255,255);
  strokeWeight(0);
  rect(0,0,400,400);  
  theta += .01;
  gamma += .05;
  x = sin(theta)*sin(gamma)*150+200;
  strokeWeight(2);
  line(0,x,400,x);
  line(x,0,x,400);
  rect(x,20,400,x-60);
}
  


   
float theta,gamma;
void setup(){ size(400, 400); }

void draw() {
  fill(255,15);
  rect(0,0,400,400);
  rect( cos(theta)*100+200,cos(gamma)*100+200,
        sin(theta)*150,sin(gamma)*150);
  theta+=.05; gamma+=.1;
  delay(50);
}
  


   
float theta,ang;
void setup(){ size(400, 400); }

void draw() {
  fill(255,25);
  rect(0,0,400,400);
  ang = radians(theta);
  line( 50, 200, sin(ang)*100+200,cos(ang)*100+200 );
  line( sin(ang)*100+200,cos(ang)*100+200, 350,200 ); 
  theta+=5;
  delay(25);    
}
  


   
float[] speeds = {.01,.02,.03,.04,.05,.06,.07,.08,.09};
float[] angles = {0,0,0,0,0,0,0,0,0};
float rad;
void setup(){ size(600, 400); }

void draw() 
{
  fill(255,255);
  rect(0,0,600,400);
  for(int i=0; i< speeds.length ; i++)  
  {   
    ellipse( sin(angles[i%9])*50+100,cos(angles[i%9])*50+200, 10, 10);
    angles[i] += speeds[i];
  }  
}

  


   
float theta,ang;
void setup(){ size(400, 400); }

void draw() {
  fill(255,25);
  rect(0,0,400,400);
  ang = radians(theta);
  ellipse( 200, 200, sin(ang)*100+200,cos(ang)*100+200 );
  theta+=5;
  delay(25);    
}
  


   
float x;
void setup() {  size(800, 400); }

void draw() {
  fill(255,255);
  rect(0,0,800,400);  
  x += 1;
  for(int i=0;i<20;i++)
  {
    line( (x+i*50)%800 +100 ,0,  (x+i*50)%800 ,400);
  }
}
  


   
float angle, pos;
void setup(){ size(600,600); }

void draw()
{
  background(255);
  pos = -abs(sin(radians(angle)));
  for(int i=0; i<40; i++)
  {
    ellipse( 100+i*10, 300, 100+i*2, 300+pos*((i+1)%2)*150 );
  }
  angle += 1;
}
  


   
float alpha;
float angle = 90;
void setup()
{
  size(300,300);
  strokeWeight(0);
}

void draw()
{
  background(255);  
  alpha = sin(radians(angle))*10;  
  fill(0,1);
  
  for(int x=0; x<20; x++)
  {
    for(int y=0; y<20; y++)
    {
        ellipse( x*20, y*20, 58+alpha, 58+alpha );
    }
  }    
  angle+=1;  
}
  


   
float angle, pos;
void setup(){  size(600,600); }

void draw()
{
  background(255);  
  for(int x=0; x<20; x++)
  {
    pos = sin( radians(angle*(x+1)) )*50;
    ellipse(  pos+200+x*10, 20*x+100, 50,50 );   
  }    
  angle+=.5;  
}
  


   
float angle, pos;
void setup(){size(600,600);}

void draw()
{  
  background(255);  
  pos = sin(radians(angle))*50;
  for(int x=0; x<10; x++){
    for(int y=0; y<10; y++){
      ellipse(  x*50+pos, y*50+50, 12,12 );
    }
  }  
  angle += 2;
}
  


   
float angle,pos_0_x,pos_0_y,pos_1_x,pos_1_y;
void setup()
{
  size(600,600);
  pos_0_x = sin(radians(angle))*100+300;
  pos_0_y = cos(radians(angle))*100+300;
}

void draw()
{ 
  fill(255,40);  
  rect(0,0,600,600);  
  angle += 370.0/6.0;  
  pos_1_x = sin(radians(angle))*100+300;
  pos_1_y = cos(radians(angle))*100+300;    
  line( pos_0_x, pos_0_y , pos_1_x, pos_1_y  );  
  pos_0_x = pos_1_x; pos_0_y = pos_1_y;    
}
  


   
float angle, c_x,c_y,this_xx, this_yy;
float elip_rad = 20;
void setup(){ size(400,400); }
void draw()
{  
  background(255);
  fill(0);  
  c_x = sin(radians(angle))*100;
  c_y = cos(radians(angle))*100;      
  ellipse( 200, 200, 100,100  );
  ellipse( 200+c_x, 200+c_y, 100,100 );
  
  for(int xx=0; xx<10; xx++){
    for(int yy=0; yy<10; yy++){       
      this_xx = xx*40+20;
      this_yy = yy*40+20;      
      c_x = sin(radians(angle))*elip_rad;
      c_y = cos(radians(angle))*elip_rad;      
      ellipse( this_xx, this_yy, elip_rad, elip_rad  );
      ellipse( this_xx+c_x, this_yy+c_y, elip_rad, elip_rad  );
    }
  }
  angle += 4;  
}