Bem o jogo da vida muita gente conhece, agora fazer ele no processing não é nada tão simples assim quanto parece, para facilitar um pouco vamos fazer umas alterações para que facilite a nossas vidas.
Essas hipoteses apenas estarão valendo para cada geração e cada trio de posições adjascentes:

• Se houver somente duas células, ocorrerá nascimento;
• Caso contrario, morte de célula.

E o código para que funcione com esse gráfico de linhas como mostrado acima, temos que fazer os seguintes códigos no processing:

int NumeroGeracao = 1;
int vivos;
int[] genNum = new int[50]; 
int[] MundoAtual = {
  0, 1, 0, 0, 1, 1, 1, 0
};
int[] MundoNovo = new int[8];
int vendasAnt = 0;
int mes = 1;

void setup() {
  frameRate(1);
  size(400, 400);
  background(0);
}

void MostraMundo() {
  for (int i=1; i<7 data-blogger-escaped--="" data-blogger-escaped-0="" data-blogger-escaped-10="" data-blogger-escaped-1="" data-blogger-escaped-20="" data-blogger-escaped-2="" data-blogger-escaped-30="" data-blogger-escaped-5="" data-blogger-escaped-8="" data-blogger-escaped-arraycopy="" data-blogger-escaped-cruzacelulas="" data-blogger-escaped-draw="" data-blogger-escaped-ellipse="" data-blogger-escaped-else="" data-blogger-escaped-for="" data-blogger-escaped-gennum="" data-blogger-escaped-grafico="" data-blogger-escaped-height-30="" data-blogger-escaped-height="" data-blogger-escaped-i="" data-blogger-escaped-if="" data-blogger-escaped-int="" data-blogger-escaped-line="" data-blogger-escaped-mes-1="" data-blogger-escaped-mes="" data-blogger-escaped-mostramundo="" data-blogger-escaped-mundoatual="" data-blogger-escaped-mundonovo="" data-blogger-escaped-numerocelulas="CruzaCelulas(i);" data-blogger-escaped-numerogeracao="" data-blogger-escaped-osicao="" data-blogger-escaped-point="" data-blogger-escaped-posicao="" data-blogger-escaped-pre="" data-blogger-escaped-println="" data-blogger-escaped-return="" data-blogger-escaped-stroke="" data-blogger-escaped-text="" data-blogger-escaped-umerocelulas="=" data-blogger-escaped-umerogeracao="" data-blogger-escaped-undoatual="" data-blogger-escaped-undonovo="" data-blogger-escaped-vendasant="genNum[NumeroGeracao];" data-blogger-escaped-vivos="0;" data-blogger-escaped-void="" data-blogger-escaped-x="" data-blogger-escaped-y="">

Para tanto agora vamos brincar um pouco com imagens, e para isso tenha resultado satisfatório vamos pegar uma imagem aleatória para tratar o brilho no processing.

Para isso pegamos a imagem do mario e do luigi para utilizarmos no processing.
E faremos o seguinte código: 

PImage imgOriginal;
float r,g,b;
float Bri;
float V = 0.01;
float a;

int pos;

void setup(){
  size(320,240);
  imgOriginal = loadImage("images2.jpg");
  
}

void draw(){
  a = Bri+1;
  loadPixels();
  for(int x = 0; x < 320; x++){
    for(int y = 0; y < 240; y++){
      pos = y* 320 + x;
      r = a*red(imgOriginal.pixels[pos]);
      b = a*blue(imgOriginal.pixels[pos]);
      g = a*green(imgOriginal.pixels[pos]);
      pixels[pos]=color(r,g,b);
    }
  }
  updatePixels();
  if(Bri<-0 data-blogger-escaped-.5="" data-blogger-escaped-else="" data-blogger-escaped-if="" data-blogger-escaped-ri="" data-blogger-escaped-v="-V;">0.5){
    V= -V;
  }
  Bri = Bri +V;
  println(a);
}

Tendo como resultado imagens como essas:

Hoje vamos recriar um relógio digital utilizando algumas imagens que vamos recortar no photoshop e padronizar o tamanho para evitar possíveis transtornos.
Os numerais usados foram esses:

E para que funcione usamos esse seguinte codigo utilizando as funções minute(), second(), hour().
Ficando assim:

PImage[] numeros = new PImage[10];
int i;
int y = 0;
void setup() {
  for (i=0; i<=9; i++) {
    numeros[i] = loadImage(i+".png");
  }
  size(300, 70);
}

void relogio() {
  int s = second();  // Values from 0 - 59
  int m = minute();  // Values from 0 - 59
  int h = hour();    // Values from 0 - 23
  image(numeros[s/10], 200, y);
  image(numeros[s%10], 200+ numeros[s/10].width, y); 
  image(numeros[m/10], 100, y);
  image(numeros[m%10], 100+numeros[m/10].width, y); 
  image(numeros[h/10], 0, y);
  image(numeros[h%10], numeros[h/10].width, y);
}

void draw() {
  background(204);
  relogio();
}

Bem hoje iremos criar um desenho de um olho, mas esse olho irá seguir o cursor do mouse, sem sair do globo ocular é claro.

E para isso usaremos algumas regrinhas de trigonometria, tais como coordenadas polares e tangentes.




Pois vamos para a codificação.

float x, y;
float angulo;

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


void olhoMovendo (float ang) {
  fill (255);
  ellipse (width/2, height/2, 300, 300);
  fill (20);
  ellipse (x, y, 100, 100);


  float distancia = distancia2D (width/2, height/2, mouseX, mouseY);
  if (distancia > 74) {
    x = (74 * cos(angulo)) + width/2;
    y = (74 * sin(angulo)) + height/2;
  } else {   
    x = mouseX;
    y = mouseY;
  }
}

float distancia2D(float dx1, float dy1, float dx2, float dy2) {
  int aux = (int) sqrt((dx2-dx1)*(dx2-dx1)+(dy2-dy1)*(dy2-dy1));
  int retorna = (int) sqrt(aux*aux);
  return retorna;
}

float limite(float x, float y) {
  if (mouseX != 0) {
    angulo = y/x;
  }
  angulo = atan(angulo);
  if (x < 0) {
    angulo = PI + angulo;
  }
  if (y <= 0 && x >= 0) {
    angulo = 2*PI + angulo;
  }
  return angulo;
}

void draw() {
  background (255);
  float tang = limite (mouseX - width/2, mouseY-height/2);
  olhoMovendo (tang);
}

Utilizando-se da trigonometria, podemos criar um relogio em tempo real. Usaremos para tal fim a lei dos cossenos, já usamos os senos, agora é a vez dos cossenos.

Vejamos agora como ficou o codigo

float angulo = 360/60;
float angulo2 = 360/12;
int raio = 100;
int raioHour =70; 


void setup() {
  size(500, 300);
}

void draw() {
  int h = hour();
  h=h%12;
  int m = minute();
  int s = second();
  
 

  println(m);


  background(255);
  noFill();
  ellipse(width/2, height/2, 210, 210);
  line(width/2, height/2, width/2 + raio* cos(radians(m*angulo- 15*angulo)), height/2 +raio* sin(radians(m*angulo - 15* angulo)));
  line(width/2, height/2, width/2 + raioHour* cos(radians(h*angulo2- 15*angulo2)), height/2 +raio* sin(radians(h*angulo2 - 15* angulo2)));
  triangle(width/2, height/2,width/2+10,height/2+10, width/2 + raio* cos(radians(m*angulo- 15*angulo)), height/2 +raio* sin(radians(m*angulo - 15* angulo)));
  triangle(width/2, height/2,width/2+10,height/2+10, width/2 + raioHour* cos(radians(h*angulo2- 15*angulo2)), height/2 +raio* sin(radians(h*angulo2 - 15* angulo2)));
  fill(125,0,0);
  triangle(width/2, height/2,width/2+10,height/2+10, width/2 + raio* cos(radians(s*angulo- 15*angulo)), height/2 +raio* sin(radians(s*angulo - 15* angulo)));
  
}

Falemos de trigonometria, e ainda por cima falaremos hoje de senos. Então vamos explicar como funciona os senos. A relação é valida para triângulos retângulos (como o nome sugere, ela veio a partir de um retângulo e possui um angulo reto 90º)

Mostremos aqui um exemplo:

 Esse triângulo: 
SEN B = b/a;

SEN C = c/a;

SEN A = 1;

E a lei dos senos representada na figura abaixo:

E os resultados de um seno, sempre quando se coloca em gráfico, ele segue uma onda, devido ao arco trigonométrico. Como mostra a figura a seguir:

Agora você se pergunta aonde eu vou chegar com isso, e é aí que vou mostrar um codigo que você pode criar a partir dessas funções do seno.

float x, y, x1, y1;
void setup() {
  size (600, 400);
  noStroke();
}

void canoa() {
  fill(130, 0, 10);
  rect(10*x, 10*y + height*3/4, 50, 10);
}

void draw() {
  background(0, 50, 200);
  y = sin(x);
  x += 0.1;
  x1 = 0;
  for (int i = 0; i < 600; i++) {
    y1 = sin(x1);
    x1 += 0.1;
    fill(0, 80, 255);
    ellipse(10*x1, 10*y1 + height*3/4, 5, 5);
    ellipse(10*x1, 10*y1 + 320, 5, 5);
    ellipse(10*x1, 10*y1 + 340, 5, 5);
    ellipse(10*x1, 10*y1 + 360, 5, 5);
    ellipse(10*x1, 10*y1 + 380, 5, 5);
    ellipse(10*x1, 10*y1 + 400, 5, 5);
  }
  canoa();
}

A brincadeira simples de desenhar polígonos nas épocas de escola agora tem um nível a mais. Agora tem que refazer aqueles desenhos no caderno no computador vide programação.
Pois vamos ao processing e desenhar um polígono qualquer mediante a uma função simples que retorne vértices para criar um polígono qualquer.







Vamos ao código:

void setup() {
  size(500,500);
}
void poligonR(float x, float y, float raio, int n) {
  noFill();
  float ang = 2*PI / n;
  beginShape();
  for (float f = 0; f < 2*PI; f += ang) {
    float Vx = x + cos(f) * raio;
    float Vy = y + sin(f) * raio;
    
    vertex(Vx, Vy);
    
  }
  endShape(CLOSE);
}
void draw() {
  background(102);
  
  poligonR(width/2, height/2, 100, 3); 
}

Bem voltamos aqui a falar sobre a logo do FourSquare, mas desta vez será um pouco diferente, trataremos do mesmo assunto passado, porem agora em um vídeo.

O vídeo encontra-se logo abaixo, então vocês poderão compreender melhor como foi feito o processo.

Nota: o áudio não me ajudou muito devido ao microfone usado não ser muito bom.