miércoles, 3 de noviembre de 2010

Mono



int holo=85;
int hello=85;

void setup() {
size(400,400);
background(255);
smooth();

println("Ready to roll!"); // pantalla abajo
int d1 = 1 + int(random(20));
println("Rolling..." + d1);
int d2 = 1 + int(random(20));
println("Rollimg..." + d2);
int d3 = 1 + int(random(6));
println("Rolling..." + d3);
println("Finished.");
}



void draw(){
background(255);
fill(255,40,120);
ellipse(100,100,100,100);
fill(255);
ellipse(110,95,50,50);
fill(0);
ellipse(88+mouseX/40,93+mouseY/40,5,5);
fill(0);
ellipse(108+mouseX/40,93+mouseY/40,5,5);
line(95,110,105,110);
line(85,hello,95,holo);
line(105,hello,115,holo);
if(mousePressed==true){
if(holo==85){holo=88;}
else if(holo==88){holo=85;}


}
}

miércoles, 27 de octubre de 2010

ejemplos


Learningprocessing

http://www.learningprocessing.com/exercises/chapter-17/exercise-17-7/
http://www.learningprocessing.com/exercises/chapter-17/exercise-17-9/

miércoles, 29 de septiembre de 2010

codigo de "robot"


int x = 60;
int y = 420;
int bodyHeight = 110;
int neckHeight = 140;
int radius = 45;
int ny = y - bodyHeight - neckHeight - radius;


size(630, 500);
smooth();
strokeWeight (2);
background (245, 247, 40);
ellipseMode (RADIUS);


stroke(20, 8, 139);
line(y, x+bodyHeight, x+2, ny);
line(y, x-bodyHeight, x+12, ny);
line(y, x+bodyHeight, x+22, ny);
line(x+12, ny, x-18, ny-43);
line(x+12, ny, x+42, ny-99);
line(x+12, ny, x+78, ny+15);


noStroke();
fill(5, 97, 199);
ellipse(y, x+200, 200, 200);
fill(118, 247, 40);
ellipse(y, x+200, 180, 180);
fill(79, 247, 40);
ellipse(y, x+200, 160, 160);
fill(40, 247, 220);
ellipse(y, x+200, 140, 140);
fill(74, 40, 247);
ellipse(y, x+200, 120, 120);
fill(191, 40, 247);
ellipse(y, x+200, 100, 100);
fill(247, 40, 230);
ellipse(y, x+200, 80, 80);
fill(74, 40, 247);
ellipse(y, x+200, 60, 60);
fill(247, 40, 167);
ellipse(y, x+200, 40, 40);
fill(247, 176, 40);
ellipse(y, x+200, 20, 20);


fill(0);
rect(x-65, y-bodyHeight, 100, bodyHeight-100);
fill(5, 97, 199);
rect(x-500, y-bodyHeight+500, 500, 500);
fill(33, 162, 72);
ellipse(x+22, ny, radius, radius);
fill(6, 216, 70);
ellipse(x+24, ny-6, 14, 14);
fill(0);
ellipse(x+24, ny-6, 3, 3);
fill(42, 250, 193);
ellipse(x, ny-8, 5, 5);
ellipse(x+90, ny-46, 4, 4);
ellipse(x+80, ny-46, 4, 4);
ellipse(x+70, ny-46, 4, 4);
ellipse(x+60, ny-46, 4, 4);
ellipse(x+50, ny-46, 4, 4);
ellipse(x+40, ny-46, 4, 4);
ellipse(x+30, ny-46, 4, 4);
ellipse(x+20, ny-46, 4, 4);
ellipse(x+81, ny+10, 6, 6);



martes, 28 de septiembre de 2010

proyecto examen.

A mi me gustaria utilizar lineas para que con ellas se formen dibujos creados por la persona que este utilizando el mouse, en openprocessing encontre algo semejante a lo que quiero realizar, pero utilizando mas colores.

Colores a utilizar


miércoles, 8 de septiembre de 2010

repaso de códigos



ellipse(40, 80, 90, 60); // línea izq
ellipse(20, 50, 40, 60);
ellipse(30, 90, 50, 60); // línea medio
ellipse(40, 50, 50, 60);
ellipse(50, 80, 90, 60); // línea der



background(0); // setea negro en background
stroke(255); // setea valores bco en líneas
strokeWeight(5); // setea ancho líneas 5 pixeles
smooth(); // suaviza bordes
ellipse(20, 90, 30, 40); // línea izq
ellipse(30, 80, 40, 40);
ellipse(40, 70, 50, 40); // línea medio
ellipse(50, 90, 60, 40);
ellipse(60, 80, 70, 40); // línea der
*

int x = 0; // setea posición horizontal
int y = 55; // setea posición vertical
void setup() {size(100, 100); // Setea la ventana de 100 x 100 pixeles
}
void draw() {
background(204);
ellipse(x, y, x+80, y-40); // línea izq
ellipse(x+20, y, x+60, y-50); // línea mitad
ellipse(x+10, y, x+30, y-50); // línea der
x = x + 1; // Suma 1 a xif (x > 100) { // Si x es mayor que 100,
x = -40; // asigna 40
}
}
*
void setup() {
size(200, 200);
noLoop();
}
void draw() {
diagonals(40, 90);
diagonals(60, 62);
diagonals(20, 40);
}
void diagonals(int x, int y) {
ellipse(y, x, x+20, y-40);
ellipse(x+20, y, x+50, y-40);
ellipse(x+40, y, x+60, y-40);
}
*
Diagonals da, db;
void setup() {
size(200, 200);
smooth();
// Inputs: x, y, velocidad, espesor, grray
da = new Diagonals(0, 90, 1, 6, 0);
db = new Diagonals(0, 55, 4, 3, 255);
}
void draw() {
background(204);
da.update();
db.update();
}
class Diagonals {
int x, y, speed, thick, gray;
Diagonals(int xpos, int ypos, int s, int t, int g) {
x = xpos;
y = ypos;
speed = s;
thick = t;gray = g;
}
void update() {
strokeWeight(thick);
stroke(gray);
ellipse(y, x, x+60, y-80);
ellipse(y+10, x, x+40, y-50);
ellipse(y+20, x, y+40, x-40);
x = x + speed;
if (x > 100) {x = -100;
}
}
}

martes, 31 de agosto de 2010

S3. Introducción a Processing

Aunque es un poco complejo todo lo que estaba planteado en el texto por el hecho de no estar aplicado directamente en processing, pero podemos decir que en este texto se habla principalmente de los diversos lenguajes que existen dentro de processing, como por ejemplo la
multiplicación (usualmente anotada con una x) se denota por un * la división
(Usualmente anotada por una línea y dos puntos arriba y abajo) se denota por un /. También como cualquier programa existen muchos tipos de formas de acortarnos el trabajo. También podemos crear nuestras propias funciones que pueden ser llamadas con cualquier código designado, esto trae muchos beneficios ya que así no es necesario escribir todo en las funciones setup() o loop().
* Re-uso: Escribir una función para un set de comandos comúnmente usados, que
puedes llamar una y otra vez. Por ejemplo, tienes una figura compleja que usarás a lo
largo de tu código.
En vez de cortar y pegar esas instrucciones por todos lados, puedes escribirlas una
sola vez y llamarlas muchas veces.
* Encapsulación: Poner funcionalidad en una función y entonces separarlas del resto
del código, ayudará en entender el programa. También ayuda a hacer cambios más
fácilmente.
La Encapsulación es una de las piedras angulares de la programación orientada a los
objetos. Con ella, podemos representar o abstrae un objeto en el código del
computador.
Podemos describir al objeto: sus rasgos, capacidades, propiedades, qué puede hacer y
qué comportamientos pueden ser modificados, para describir las reglas de un sistema
o para mimetizar el comportamiento de un objeto en el mundo real.

martes, 24 de agosto de 2010

texto 2.

A mi juicio en general processing es entretenido, pero difícil, en este texto se muestra de manera entretenida lo que puede llegar hacer cualquier persona con los conocimientos necesarios para llegar hacer hermosas propuestas, pero siempre con un grado de dificultad que son el tema de loop, y los enteros (println). Siempre los ejemplos son de gran ayuda pero en este caso insertaban a seguir con la investigación de este programa.