�ݺ�ߣ

Introduzione a

Processing

Prof. Christian Gervasi

Conosciamo il linguaggio di programmazione open-source
creato per realizzare

immagini e animazioni,

le cui librerie ed il cui ambiente sono compatibili con l’ambiente di sviluppo di

Arduino.
INDICE

•Introduzione
programma scritto in Processing;
1.LEZIONE 1 FORME BASE
6. LEZIONE 6 CONTROLLO DI
come disegnare linee, rettangoli,
FLUSSO_
cerchi, quadrilateri sull’area
RIPETIZIONI; questo programma
2. LEZIONE 2 FORME BASE; rispetto descrive l’uso dei cicli FOR;
al programma precedente, aggiunge 7. LEZIONE 1_7 CONTROLLO DI
le funzionalità legate al tratto di
FLUSSO_
disegno ed al riempimento di colore IF; questo programma mostra
delle figure;
l’utilizzo del costrutto condizionale
3. LEZIONE 3 COLORI BASE; illustra IF;
le funzionalità legate a colori,
8. LEZIONE 1_8 USO DEL TESTO;
riempimenti e trasparenze;
aggiungiamo del testo al
4. LEZIONE 4 ELETTRINO 1; questo programma dell’esercizio
programma permette di disegnare precedente;
un robot con le funzionalità
9. LEZIONE 1_9 - ANIMAZIONE;
descritte nei programmi precedenti;
realizziamo una semplice
5. LEZIONE 5 STRUTTURA BASE DI
animazione
UN PROGRAMMA; in esso viene
10. EXTRA – PLASMA FADING
mostrata la struttura base di un

Introduzione

Pocessing
è un linguaggio di
programmazione sviluppato
con il preciso scopo di
rendere molto semplice
l’interazione con elementi
grafici; più esattamente, è

finalizzato alla
realizzazione di
immagini, animazioni e
interazioni.

home


Introduzione
Processing è stato
sviluppato
dal 2001, con la finalità di
ottenere un linguaggio
semplice per gli studenti di
arte e design e per quelli ad
indirizzo tecnico.
Grafica 3D, comunicazione
seriale, interfacciamento
con Arduino, audio.
Processing e le sue librerie
sono completamente liberi,
progetto open source

home


Introduzione
Generalmente quando
si studia un linguaggio
di programmazione si
parte sostanzialmente
dalla struttura, dai
concetti teorici, dagli
algoritmi e dai vari
metodi di
programmazione,
relegando alla fine
l’interazione con la
grafica e magari le
animazioni. Utilizzando
Processing, si parte
direttamente
da grafica e
animazioni, fermo
restando che devono
essere compresi le
strutture di
programmazione e i
vari costrutti.
home


Introduzione
La piena compatibilità con Arduino è un altro aspetto che
rende Processing estremamente interessante, senza
contare che gli ambienti di programmazione sono
praticamente Identici
Alla fine di questo corso si avranno le nozioni base per
realizzare una GUI (Graphic User Interface) completa con la
quale sarà possibile controllare Arduino.

home


Introduzione
PROCESSING DEVELOPMENT ENVIRONMENT (PDE)

•Text Editor, dove verranno scritti i
programmi;
• Toolbar
•Message Area. La Message Area è usata
per inviare da Processing i messaggi di
errore,
• Console: serve per trasmettere,
ad esempio, dei messaggi dal programma
in
Esecuzione.
I programmi creati con Processing
vengono chiamati sketch
La Toolbar è composta dai pulsanti:
1. RUN – avvia il programma;
2. STOP – ferma il programma;
3. NEW – apre un altro editor;
4. OPEN – apre un altro programma;
5. SAVE – salva il lavoro corrente .pde;
6. EXPORT – crea una cartella unica con
tutto il lavoro realizzato, che può essere
installata su un web-server ed è
composta da un fi le .pde che è il codice
sorgente; il fi le .jar sarà il programma,
mentre il fi le .html corrisponde alla
pagina web.

home


LEZIONE 1 FORME BASE

Andiamo allora a
rappresentare sullo
schermo delle figure
geometriche
utilizzando le funzioni
native di Processing.

home


Iniziamo a disegnare l’area in cui
andremo a disegnare le nostre
forme. Essa è defi nita dalla
funzione:

size()
le dimensioni dell’area di disegno
sono definite in pixel e i parametri
da passare alla funzione sono width
ed eight, larghezza ed altezza.
L’origine 0,0 del piano di disegno è
posta nello spigolo in alto a sinistra, la
direzione
di incremento dell’asse X è verso
destra, mentre la direzione di
incremento dell’asse
Y è verso il basso.

size(260,400); //dimensioni X,Y dell’area di disegno
home



La funzione

background()

permette di definire il
colore di sfondo del piano
di disegno; inserendo un
solo valore che va da 0 a
255, Processing
riconoscerà che stiamo
lavorando in scala di grigi

background(205); //sfondo dell’area di disegno, in gradazione di grigio

home


Il comando

smooth()
evita la spigolosità
delle varie forme disegnate,
mentre

strokeWeight()
definisce lo spessore del tratto
in pixel.

smooth(); //forme disegnate meno spigolose
strokeWeight(2); //spessore del tratto di disegno pin px

home



Le linee vengono disegnate con il
comando

line()

che si aspetta le coordinate
del punto di

partenza (X1,Y1)
e di quello di

arrivo (X2,Y2).

line(60,60,200,20); //linea X1,Y1, X2,Y2
home



triangle()

disegna dei triangoli e dobbiamo
defi nire le coordinate dei tre
vertici
(X1,Y1,X2,Y2,X3,Y3)

triangle(200,60,200,100,60,100); //triangolo X1,Y1,X2,Y2,X3,Y3

home



Per disegnare dei quadrilateri
si usa il comando

quad()

inserendo
le coordinate dei quattro vertici.
quadrilatero
X1,Y1,X2,Y2,X3,Y3,X4,Y4

quad(100,120,180,140,160,160,60,160); //quadrilatero X1,Y1,X2,Y2,X3,Y3,X4,Y4

home


Diverso
è il caso per i rettangoli, che sono
disegnati
con il comando

rect()

i cui parametri sono
le coordinate X,Y dello spigolo in
alto a
sinistra, la larghezza del
rettangolo e la sua
altezza.

rect(80,200,100,40); //rettangolo X,Y, larghezza, altezza
home


le ellissi; il comando
corrispondente è

ellipse()

i cui parametri sono le coordinate
X,Y
del centro la larghezza e l’altezza
(ovviamente
se altezza e larghezza sono
identiche
otterremo un cerchio).

ellipse(120,280,50,50); //ellisse X,Y, larghezza, altezza
home



arc()

il
cui funzionamento è identico a
ellipse(), ma
ha due parametri in più, che sono
l’angolo
di inizio e l’angolo di fine
(espressi in radianti
e con verso positivo di crescita
quello
antiorario).

arc(120, 350, 70, 70, 0, PI+HALF_PI);
//arco X,Y, largh, Altezza, ang inizio, ang fine

home



Sketch
size(260,400); //dimensioni X,Y dell’area di disegno
background(205); //sfondo dell’area di disegno, in gradazione di grigio
smooth(); //forme disegnate meno spigolose
strokeWeight(2); //spessore del tratto di disegno pin px
line(60,60,200,20); //linea X1,Y1, X2,Y2
triangle(200,60,200,100,60,100); //triangolo X1,Y1,X2,Y2,X3,Y3
quad(100,120,180,140,160,160,60,160); //quadrilatero X1,Y1,X2,Y2,X3,Y3,X4,Y4

rect(80,200,100,40); //rettangolo X,Y, larghezza, altezza
ellipse(120,280,50,50); //ellisse X,Y, larghezza, altezza
arc(120, 350, 70, 70, 0, PI+HALF_PI); //arco X,Y, largh, Altezza, ang inizio, ang fine

home


prima di ogni
primitiva di disegno definisce

fill()
e

strokeWeight().

Ne consegue che ogni forma
disegnata avrà il suo colore di
riempimento
ed il suo spessore del tratto di
disegno. La
Fig. 2 mostra le forme base del
programma
precedente, mentre la Fig. 3
illustra le forme
base con le nuove funzionalità
appena
descritte.

fill(255, 0, 0);

//riempimento di colore rosso
home


LEZIONE 3 COLORI BASE

Il codice di questo terzo
programma mostra
come utilizzare i colori e le
funzionalità di
Processing relativamente alle
trasparenze;
con esso vengono disegnate due
combinazioni di tre cerchi con i
colori
base. Nella prima sequenza
i colori sono pieni e non ci
sono trasparenze, mentre nella
seconda vengono utilizzate le
trasparenze Fig. 4. Trovate il
codice corrispondente a questo

home


La prima sequenza
i colori sono pieni e non ci
sono trasparenze
smooth(); //questa funzione permette di rendere
le forme disegnate meno spigolose
noStroke(); //con questa funzione le forme
disegnate sono prive di contorno

fill(255, 0, 0); //riempimento di colore rosso
ellipse(80,80,140,140); //prima circonferenza

fill(0, 255, 0); //riempimento di colore verde
ellipse(200,80,140,140); //seconda circonferenza

fill(0, 0, 255); //riempimento di colore blu
ellipse(140,140,140,140); //terza circonferenza

home


Nella seconda vengono utilizzate
le trasparenze
//oltre ai colori si può impostare la trasparenza
//i valori vanno da 0 --> 255

nella funzione fill() possiamo
mettere quattro parametri: R,G,B,
trasparenza
fill(255, 0, 0,100); //riempimento di colore
rosso e trasparenza 100
ellipse(80,280,140,140); //prima
circonferenza
fill(0, 255, 0, 100); //riempimento di colore
verde e trasparenza 100

ellipse(200,280,140,140); //seconda
circonferenza
fill(0, 0, 255, 100); //riempimento di colore blu
e trasparenza 100
ellipse(140,340,140,140); //terza
circonferenza

home



home


LEZIONE 4 ELETTRINO
A questo punto mettiamo
assieme
tutte le funzioni descritte
ed incominciamo a
realizzare
un disegno.
Il codice di questo quarto
programma
permette di combinare
le forme base per
disegnare
un piccolo robot (Fig. 5)
cui
diamo il nome di Elettrino e
che richiameremo più
avanti
in successivi programmi,
nei quali saranno
aggiunte altre funzionalità

home


LEZIONE 4 ELETTRINO
/*
Corso Arduino+Processing
Lezione 1_4
ELETTRINO_1
il codice qui descritto si riferisce alle funzioni base di disegno di P5
ed al disegno di ElettrInO
28_Sett_2010
Christian Gervasi
*/

size(560,400);
smooth();
strokeWeight(2);
background(204);
ellipseMode(RADIUS);

//antenne
strokeWeight(2);
line(200,20,240,80);
line(380,20,300,80);
//collo
strokeWeight(10);
line(280,160,280,200);
strokeWeight(1);

home


LEZIONE 4 ELETTRINO
//testa
fill(50);
rect(160,80,240,80);
//occhio sinistro
fill(255);
ellipse(220,120,20,20);
fill(5);
ellipse(220,120,6,6);
//occhio destro
fill(255);
ellipse(340,120,20,20);
fill(5);
ellipse(340,120,6,6);
//bocca
fill(160);
rect(260,140,40,20);

home


LEZIONE 4 ELETTRINO

//corpo
fill(50);
rect(200,200,160,140);

//ruote
fill(120);
ellipse(240,360,20,20);
ellipse(320,360,20,20);
//braccio sinistro
line(140,240,200,240);
arc(120,240,20,20,PI,TWO_PI+HALF_PI);

//braccio destro
line(360,240,420,280);
arc(420,280,20,20,0,PI+HALF_PI);

home


LEZIONE 5 STRUTTURA BASE DI UN PROGRAMMA

Il quinto programma esegue
un ciclo in cui
nel terminale viene scritto
continuamente
un numero che viene
incrementato ad ogni
ciclo

home


La struttura di un programma
scritto in Processing si compone
di tre parti
fondamentali:
• la dichiarazione delle variabili;
• void setup(){} che è una parte
di codice
eseguito una sola volta;
• void draw(){} che invece è la
parte di
codice eseguita continuamente

home



Nel programma appena descritto (Listato
3) è stata utilizzata la funzione delay(1000);
che permette di creare un ritardo di 1 secondo;
in pratica l’argomento della funzione è
un numero che esprime il ritardo in ms.
La scrittura cont +=1; significa che la variabile
cont viene incrementata di un’unità ad
ogni ciclo.

home


/*
Lezione 1_5
STRUTTURA BASE DI UN PROGRAMMA
il codice qui descritto si riferisce alle strutture base si un programma in P5
1) dichiarazione di variabili
2) setup()
3) draw()
28_Sett_2010
Christian Gervasi
*/

int cont;

//dichiarazione della variabile cont come intero

//setup viene eseguito una sola volta
void setup(){
cont=0;
//inizializzazione della variabile cont
println("SETUP - eseguito una sola volta"); //scrittura a terminale
}
//draw è un ciclo che viene eseguito continuamente
void draw(){
println("ciclo continuo - in esecuzione"); //scrittura a terminale
println(cont); //scrittura a terminale del valore di cont
delay(1000); //attesa di 1 secondo, il valore di delay() è espresso in ms
cont +=1;
//incremento di cont di 1 ad ogni ciclo
}

home


LEZIONE 6 CONTROLLO DI FLUSSO RIPETIZIONI
Introduce l’utilizzo
dei controlli di flusso. Il codice serve a disegnare una
ripetizione di cerchi di colore diverso; questa funzionalità è
ottenuta attraverso un ciclo

FOR.

home


Quest’ultimo è descritto dalla variabile che viene
incrementata ad ogni ripetizione, dalla condizione per cui il
ciclo viene ripetuto (in pratica, finché la condizione è vera
il ciclo viene ripetuto, mentre quando diventa falsa il
programma esce dal ciclo) ed infine dall’incremento della
variabile.

home


Nel caso del programma in questione, la variabile che viene
incrementata è
i
definita come intero for(int i ….
La condizione per cui il ciclo è ripetuto è:
“fintanto che i è minore di 480”

for (int i; i<480....

Invece l’incremento della variabile i ad ogni
ciclo è 40:

for (int i; i< 480; i +=40).

home



/*
Lezione 1_6
CONTROLLO DI FLUSSO - RIPETIZIONI
FOR
28_Sett_2010
Christian Gervasi
*/

size(480,120);
smooth();
background(0,0,0);
strokeWeight(1);

// sfondo nero

//ciclo for
for (int i = 40; i<480; i +=40){ //variabile di conteggio i, che parte da 40 fino a 280, con
incrementi di 40 per ogni ciclo
fill(50+i/2, 90+i/10, 200); //riempimento, i colori variano in modo proporzionale con
l'incremento di i
ellipse (i, 60, 60, 60);
//vengono disegnati cerchi, la cui posizione X è i
}

home


LEZIONE 7 CONTROLLO DI FLUSSO_

Permette di disegnare un
quadrato con
all’interno quattro quadranti;
spostando
il cursore del mouse sopra un
quadrante,
questo cambia di colore

home



In pratica si tratta di una
condizione con
quattro AND logici (&&) che
verifica se la
posizione X del mouse è

tra X1 e X2

e se laposizione Y del mouse è

tra Y1 e Y2;

se tutte e quattro le condizioni
sono verificate, la condizione
complessiva è vera e di
conseguenza viene colorata l’area

home



int x1 = 0;
int y1 = 0;
int x2 = 100;
int y2 = 0;
int x3 = 100;
int y3 = 100;
int x4 = 0;
int y4 =100;
int h = 100;
int l = 100;
void setup()
{
size(200,200);
}
void draw()
{

home



//costruzione rettangolo QUADRANTE 1
if ((mouseX > x1) && (mouseX < x2) && (mouseY
> y1) _
&& (mouseY < y3))
{ //condizione di verifica se il mouse è nel
QUADRANTE 1
fill(0);
} else
{ fill(255); }
rect(x1,y1,l,h);
if ((mouseX > x2) && (mouseX < width) && _
(mouseY > y2) && (mouseY < y4))
QUADRANTE 2
fill(0);
} else
{ fill(255); }
rect(x2,y1,l,h);

home



(mouseY > y3) && (mouseY < height))
QUADRANTE 3
fill(0);
} else
{ fill(255); }
rect(x3,y3,l,h);
if ((mouseX > x4) && (mouseX < x3) && _
QUADRANTE 4
fill(0);
} else
{ fill(255); }
rect(x4,y4,l,h);
}

home


int x1 = 0;
int y1 = 0;
int x2 = 100;
int y2 = 0;
int x3 = 100;
int y3 = 100;
int x4 = 0;
int y4 =100;
int h = 100;
int l = 100;
void setup()
{
size(200,200);
}
void draw()
{
if ((mouseX > x1) && (mouseX < x2) && (mouseY > y1) _
&& (mouseY < y3))
{ //condizione di verifica se il mouse è nel QUADRANTE 1
fill(0);
} else
{ fill(255); }
rect(x1,y1,l,h);
(mouseY > y2) && (mouseY < y4))
fill(0);
} else
{ fill(255); }
rect(x2,y1,l,h);
fill(0);
} else
{ fill(255); }
rect(x3,y3,l,h);
if ((mouseX > x4) && (mouseX < x3) && _
fill(0);
} else
{ fill(255); }
rect(x4,y4,l,h);
}

home


LEZIONE 8 USO DEL TESTO

Questo programma aggiunge,
rispetto al precedente, del testo
per identificare i quadranti il
comando qui utilizzato
è:

Text

(“testo da scrivere”, posizione X,

home


/*
Lezione 1_8
CONTROLLO DI FLUSSO - COSTRUTTI
CONDZIONALI
IF
UTILIZZO DEL TESTO
28_Sett_2010
Christian Gervasi
*/
int x1 = 0;
int y1 = 0;
int x2 = 100;
int y2 = 0;
int x3 = 100;
int y3 = 100;
int x4 = 0;
int y4 =100;
int h = 100;
int l = 100;
void setup(){
size(200,200);
textSize(12);
textAlign(LEFT);
}

home



void draw(){
if ((mouseX > x1) && (mouseX < x2) &&
il mouse è nel QUADRANTE 1
(mouseY > y1) && (mouseY < y3)){
fill(100);
} else {
fill(250);
}
rect(x1,y1,l,h);

//condizione di verifica se

if ((mouseX > x2) && (mouseX < width) && //condizione di verifica
se il mouse è nel QUADRANTE 2
fill(100);
} else {
fill(255);
}
rect(x2,y1,l,h);

home



if ((mouseX > x2) && (mouseX < width) && //condizione di verifica se il
mouse è nel QUADRANTE 3
(mouseY > y3) && (mouseY < height)){
fill(100);
} else {
fill(255);
}
rect(x3,y3,l,h);
if ((mouseX > x4) && (mouseX < x3) && //condizione di verifica se il
mouse è nel QUADRANTE 4
fill(100);
} else {
fill(255);
}
rect(x4,y4,l,h);

fill(0);
text("x1,y1",15+x1,15+y1);
text("x2,y2",15+x2,15+y2);
text("x3,y3",15+x3,15+y3);
text("x4,y4",15+x4,15+y4);
}

home


/*
Lezione 1_8
CONTROLLO DI FLUSSO - COSTRUTTI CONDZIONALI
IF
UTILIZZO DEL TESTO
28_Sett_2010
Christian Gervasi
*/
int x1 = 0;
int y1 = 0;
int x2 = 100;
int y2 = 0;
int x3 = 100;
int y3 = 100;
int x4 = 0;
int y4 =100;
int h = 100;
int l = 100;
void setup(){
size(200,200);
textSize(12);
textAlign(LEFT);
}
void draw(){
if ((mouseX > x1) && (mouseX < x2) &&
fill(100);
} else {
fill(250);
}
rect(x1,y1,l,h);

//condizione di verifica se il mouse è nel QUADRANTE 1

if ((mouseX > x2) && (mouseX < width) && //condizione di verifica se il mouse è nel QUADRANTE 2
fill(100);
} else {
fill(255);
}
rect(x2,y1,l,h);
if ((mouseX > x2) && (mouseX < width) && //condizione di verifica se il mouse è nel QUADRANTE 3
fill(100);
} else {
fill(255);
}
rect(x3,y3,l,h);

if ((mouseX > x4) && (mouseX < x3) && //condizione di verifica se il mouse è nel QUADRANTE 4
fill(100);
} else {
fill(255);
}
rect(x4,y4,l,h);

}

fill(0);
text("x1,y1",15+x1,15+y1);
text("x2,y2",15+x2,15+y2);
text("x3,y3",15+x3,15+y3);
text("x4,y4",15+x4,15+y4);

home


LEZIONE 9 - ANIMAZIONE
consistente in un’ellisse che oscilla in verticale tra due posizioni

home



Il programma si basa sul concetto
fondamentale
in Processing, secondo cui

void draw(){}
viene ripetuto continuamente;
per la precisione,
tale funzione è richiamata
di regola,

60 volte al secondo
Sfruttando questo principio possiamo realizzare delle
Animazioni.

home


La tecnica base è quella di creare una figura
in una certa posizione, quindi cancellarla
nel frame successivo e ridisegnarla in una
posizione differente dalla prima.
L’oscillazione sull’asse verticale della

home


L’oscillazione sull’asse verticale della posizione
dell’ellisse è ottenuta mediante la
formula:

float y1 = offset + (sin(angolo))*scala;

home



La posizione è definita da

Y1

, angolo è una
variabile che viene incrementata ad ogni
ciclo,
mentre la funzione

sin()

(funzione seno
di un angolo espresso in radianti) restituisce
un numero compreso tra -1 e 1. La variabile
scala moltiplica sostanzialmente il valore
della funzione sin(), mentre

offset

rappresenta
la posizione iniziale attorno alla quale
avviene l’oscillazione.

home



La variabile di angolo verrà
incrementata
indefinitamente (perlomeno fino
alla sua totale
occupazione del campo di
memoria e poi ricomincerà), ma
la funzione seno è periodica
di 2pi, quindi il numero che ne
consegue dal continuo
incremento di angolo sarà un
multiplo di 2pi ed il risultato della
funzione
seno sarà sempre compreso tra
-1 e 1.

home


Variando le costanti iniziali, ossia angolo, offset, scala e
velocità, si può sperimentare cosa accade.

home



/*
Lezione 1_9
ANIMAZIONE
il codice qui descritto si riferisce alle funzioni base di disegno di P5
28_Sett_2010
Christian Gervasi
*/
float
float
float
float

angolo = 0.0; //angolo
offset = 200; //posizione iniziale dell'ellisse
scala = 60; //ampiezza dell'oscillazione
velocita = 0.02; //velocità dell'oscillazione

void setup(){
size(560,400);
smooth();
strokeWeight(1);
background(0);
ellipseMode(RADIUS);
}
void draw(){
fill(0,0,0);
//riempimento di colore nero
rect(0,0,560,400); //disegno di un rettangolo di colore nero di dimensioni pari all'area di disegno
float y1 = offset + (sin(angolo))*scala; //calcolo della nuova posizione Y dell'ellisse
fill(0,220,200);
// colore di riempimento dell'ellisse
ellipse(280, y1, 30, 30); //disegnod dell'ellisse
angolo += velocita; //incremento ad ogni ciclo della variabile angolo
}

home


EXTRA – PLASMA FADING
EXTRA – PLASMA FADING
La finalità di Processing è, come già detto, costituire un
linguaggio semplice per applicazioni di grafica e design; il
codice
plasma_fadig.pde
esempio di questo corso si riferisce proprio a ciò. Si tratta di
un’applicazione in cui viene disegnato un raggio colorato che
ruota a tutto schermo.
Siete invitati a variare i parametri del codice per
sperimentare cosa accade in pratica.

home


/*
PLASMA_FADING
il codice qui riportato si riferisce alla creazione di un effetto visivo di grafica e animazione. Si tratta di un raggio
colorato, composto da cerchi in dissolvenza che ruota sullo schermo.
*/
float angle = 0.0;
float offset = 30;
float scalar = 20;
float speed = 0.05;
int scala=1;
void setup() {
size(1600,1000);
//l'applicazione utilizza l'intero schermo
color(HSB);
colore scelta è Hue, Saturation, Brightness
smooth();
smussate
noStroke();
prive di contorno
background(0);
}

//la modalità di
//le linee sono
//le figure sono
//lo sfondo è nero

void draw() {
float h=110*(sin(angle)+1);
float s=110*(cos(angle)+1);
float b=110*(sin(angle)+1);
println(int(h));
println(int(s));
println(int(b));
fill(int(h),int(s),int(b));

//colore di riempimento dei cerchi

//i cerchi descrivono una circonferenza nel piano, questo è ottenuto calcolando il punto XY riferito al centro del
cerchio

float x = offset+ (random(30))*0.03 + cos(angle) * scalar;
posizione X dei cerchi
float y = offset+(random(50))*0.03 + sin(angle) * scalar;
posizione Y dei cerchi
//i cerchi disegnati sono 20
for(int i=0; i<20; i++){
fill(int(h)+i*30,int(s)+i*30,int(b)*(i/10),i*10);
della loro dimensione
ellipse( x*i+i*30, y*i+i*30, 10*i+i*30, 10*i+i*30);
}

//calcolo della
//calcolo della

//calcolo della traslazione dei cerchi e

//ad ogni giro del programma angle è incrementato di speed, aumnetando speed aumenta la velocità di rotazione
angle += speed;
//riempimento di sfondo
fill(0,0,0,10);
//riempimento nero, ma con trasparenza 10
rect(200,500,300,400);
//il rettangolo che volta per volta viene aggiunto crea un effetto
dissolvenza
}

home


�ݺ�ߣ

01-Processing

Recommended

More Related Content

Similar to 01-Processing (17)

More from GervasiChristian (20)

01-Processing