Dans Processing, la commande noise permet de distribuer harmonieusement une succession de valeurs d’apparence aléatoire. Ainsi, pour obtenir une animation d’un ensemble de lignes offrant l’apparence d’une crête défilante sur la fenêtre de notre programme, nous pouvons procéder de la sorte.
float valeur;
float echelle=0.02;
float moment=0;
void draw() {
background(255);
moment+=0.5;
for (int x = 0; x < width; x+=2) {
valeur = noise((moment+x) * echelle );
line(x, 0, x, valeur*height);
}
La variable valeur enregistrera le résultat produit de l’addition d’un moment et d’une position relative dans l’espace x multipliée par l’échelle de bruit souhaitée. Le résultat d’une telle opération étant toujours comprise sur l’intervalle [0; 1] nous multiplions celui-ci par un coefficient quelconque désiré pour l’obtention de notre rendu.
Ce bruit peut être aussi régi et ordonnancé par octaves et nuancé par une valeur comprise sur l’intervalle [0; 1] grâce à la commande noiseDetail(). Deux arguments sont ici requis lors de son utilisation. Un entier pour l’octave puis un décimal. L’illustration qui suit présente un seul et même pattern de bruit de Perlin où chaque subdivision gagne sur l’axe vertical un octave, partant de 1, et sur l’axe horizontal une valeur de variante partant de 0.1 à laquelle s’ajoute 0.1.
Ce jeu arpégé est utile pour l’obtention de textures procédurales et de mouvements physiques spécifiques. Néanmoins, il faut garder à l’esprit que cette distribution harmonique, selon les paramètres choisis, délaisse certaines occurrences. Les 4 graphiques suivant constatent ce fait. Il relatent le tirage de 20000 sur l’intervalle [0; 9] .
Les 3 premiers emploient la commande noise() réglée au quatrième octave avec pour facteur 0.1, 0.5 et 0.9. À la lecture de ces schémas 1 et 3, on constatera que certaines occurrences ont tout simplement disparu de l’intervalle. Ainsi en invoquant noiseDetail(4, 0.9), pas moins de 5000 occurrences ne se situent pas sur l’intervalle[0; 9]. En effet, afin de réaliser une suite harmonique logique ces occurrences ont été portées et distribuées sur l’octave suivant. Pour le dernier est employé la commande classique d’aléatoire random() dont la distribution semble équidistante mais surtout répartie sur le strict intervalle déclaré.
L’emploi d’une liste à cet instant peut nous être d’un grand secours si nous souhaitons raccorder les valeurs résultantes les unes après les autres. Nous utiliserons successivement 2 boucles itératives; une permettant de stocker dans une liste y de n données, et une seconde ordonnant le dessin en raccordant l’une des extrémités d’un segment une coordonnée (y[x]) à celle qui la suit (y[x+1]). Cette forme d’anticipation, vous l’aurez deviné, oblige à effectuer dans la déclaration de limite de la boucle cette opération consistant à écrire (x < n-1). En effet si n n’est pas contraint à sa valeur moins un, une valeur sera recherchée à l’index 51 de la liste y[] par la coordonnée y[x+1]. Cet index n’existant pas le programme affichera une erreur, dont la sanction immédiate se traduira par l’impossibilité de lancer l’animation.
float valeur;
float echelle=0.02;
float moment=0;
int n = 50;
float []y = new float [n];
void draw() {
smooth();
background(255);
moment+=0.5;
for ( int x = 0; x < n; x++ ) {
noiseDetail(4, 0.5);
valeur = noise((moment+x) * echelle );
y[x] = valeur*100;
}
for (int x = 0; x < n-1; x++) {
line(x*2, y[x], x*2 + 2, y[x+1]);
}
}
Il est avec cette simple opération aisée de liaison grâce à une liste de réaliser un terrain mouvant dont la hauteur de chaque coordonnée d’une parcelle sera relative à une valeur de bruit obtenue.
float valeur; //value
float echelle=0.05; //noise scale
float moment=0;
float gs = 30; //grid size
int subdiv = 30; //divisions w and h
int n = subdiv*subdiv; //array´s size
float []z = new float [n];
void setup()
{
size( 800, 600, P3D );
noStroke();
}
void draw()
{
lights();
background(255);
moment+=.025;
for (int y = 0; y < subdiv; y++) {
for (int x = 0; x < subdiv; x++) {
//noiseDetail(6,0.3);
valeur = noise( ( -moment + x ) * echelle, (y) * echelle );
z[x*10+y] = valeur*255;
stroke(valeur*255);
point(x, y);
}
}
noStroke();
pushMatrix();
translate( width/2-(gs*subdiv/2), height, -400 );
rotateX(HALF_PI);
for (int i=0; i<subdiv-1; i++) {
beginShape(TRIANGLE_STRIP);
for (int j=0; j<subdiv; j++) {
// fill(((z[j * 10 + i]) *-1) + 160);vertex( i * gs, j*gs, z[j * 10 + i]*2 );
vertex( (i * gs) + gs, (j*gs), z[(j*10+i)+1]*2 );
}
endShape();
}
popMatrix();
}
Read More
