Atlas des noises

Pourquoi pas simplement rand() ?

rand() donne une valeur totalement indépendante pour chaque point : deux points voisins n'ont rien à voir. C'est du bruit blanc, de la « neige » de télé. Inutilisable pour déformer une surface ou pousser de la fumée : ça grésille.

Un noise cohérent (Perlin, Worley…) respecte quatre règles :

• Continu : deux points proches ont des valeurs proches.
• Déterministe : même position → même valeur, à chaque frame, sur chaque machine. C'est ce qui rend le résultat stable au render et au cache.
• Taille de détail contrôlée : les motifs ont une taille typique (l'Element Size).
• Pas de répétition visible, alors qu'il est calculé à partir d'une petite grille.

L'astuce commune : on place du hasard seulement sur une grille (ou sur des points épars), puis on interpole en douceur entre ces points. Compare les trois modes à droite :

• Value noise : une valeur aléatoire à chaque point de grille, on relie en courbe douce. Simple, mais on devine la grille (les pics tombent sur les points).
• Gradient noise (le principe de Perlin) : à chaque point de grille on tire une pente aléatoire, et la courbe vaut 0 sur le point. Les bosses tombent entre les points de grille : beaucoup plus naturel.

Un noise, c'est du hasard « rangé » sur une grille, puis lissé. Chaque famille change juste la façon de ranger et de lisser.

Perlin et ses cousins

Comment ça marche (Perlin), pour un point P :

1. On trouve la case de la grille qui contient P (4 coins en 2D, 8 en 3D).
2. Chaque coin possède un vecteur gradient aléatoire mais fixe (tiré d'une table avec un hash des coordonnées du coin : c'est ça, le côté déterministe).
3. Pour chaque coin : dot(gradient, P − coin). Si P est « dans le sens » de la flèche, la valeur monte.
4. On mélange les 4 résultats avec une courbe de fade en S (6t⁵−15t⁴+10t³) pour que les jonctions entre cases soient invisibles.

Dans l'explorateur, active Montrer la structure sur Perlin : les flèches orange sont les gradients. Les zones claires sont devant les flèches, les zones sombres derrière.

Les variantes du menu :

• Fast : basé sur la fonction VEX onoise(). Même principe, calcul moins cher, look légèrement différent. Houdini multiplie sa fréquence par 1.25, donc à Element Size égal les motifs sont plus petits.
• Simplex (xnoise()) : la grille carrée est remplacée par des triangles (tétraèdres en 3D). Moins de coins à évaluer (3 au lieu de 4 en 2D, 4 au lieu de 8 en 3D, 5 au lieu de 16 en 4D) et moins d'alignements sur les axes. Intéressant en noise animé 4D.
• Perlin Flow (flownoise()) : au lieu de translater le noise dans le temps, on fait tourner les gradients avec Flow Rotation. Le motif bouillonne sur place au lieu de glisser. Une rotation de 0 à 1 fait un tour complet, donc l'animation boucle parfaitement. Active « Animer la rotation » dans l'explorateur et regarde les flèches.

Perlin vaut toujours « zéro » (0.5 en sortie) pile sur les coins de la grille. C'est pour ça que la doc Houdini conseille un Offset non nul : autour de 0, on voit apparaître des artefacts.

Worley : tout est question de distance

Comment ça marche :

1. On découpe l'espace en cases et on sème un point aléatoire par case (les « feature points »).
2. Pour un point P, on regarde les points des cases voisines (3×3 en 2D, 3×3×3 en 3D).
3. F1 = distance au point le plus proche. F2 = distance au deuxième plus proche.

F1 vaut 0 sur chaque feature point et grandit en s'éloignant : taches sombres, dômes, cratères. F2 − F1 vaut 0 quand P est à égale distance de deux points, c'est-à-dire pile sur la frontière entre deux cellules : on obtient un réseau de lignes (fissures, écailles, sol sec, caustiques).

Dans l'explorateur, choisis Worley Cellular F2-F1 et survole l'image : la ligne pleine va au point F1, la ligne pointillée au point F2, et le cercle a un rayon égal à F1.

Manhattan et Chebyshev ne changent qu'une chose : la formule de la distance. Le « cercle » de rayon 1 change de forme, et toutes les cellules héritent de cette forme.

Bonus VEX : wnoise() renvoie aussi un seed unique par cellule. @Cd = rand(seed); donne une couleur par cellule, pratique pour des variations par morceau.

F1 = « à quelle distance est le point le plus proche ? ». F2 − F1 = « suis-je près d'une frontière ? ».

Sparse Convolution et Alligator : des tampons

Imagine un tampon encreur rond et doux (un noyau, ou kernel) : fort au centre, nul à son bord, comme un metaball. On le pose à plein d'endroits aléatoires. C'est la convolution éparse : « éparse » parce qu'on ne pose des tampons qu'à quelques points, pas partout.

• Sparse Convolution (snoise()) : chaque tampon a un poids aléatoire, positif ou négatif, et on additionne tous ceux qui touchent P. Résultat : des blobs doux, sans grille visible du tout. La doc Houdini parle d'un roll-off « comme un metaball ». Dans les vignettes, les points orange poussent vers le haut, les bleus vers le bas.
• Alligator (anoise()) : chaque point porte une bosse de hauteur aléatoire, et on garde la plus haute. Là où deux bosses se rencontrent, on obtient un pli net en « V ». Ça ressemble à de la peau d'alligator, d'où le nom. Houdini précise que c'est un cousin du Worley qu'on ne peut pas reproduire exactement avec les fonctions Worley.

Attention à l'échelle : dans Unified Noise, Sparse Convolution a une fréquence ×1.25 et Alligator ×1.64. Passer de Perlin à Alligator sans toucher à l'Element Size donne donc des motifs plus petits.

Sparse = tampons additionnés (blobs). Alligator = on garde la bosse la plus haute (bosses + plis).

Fractal : empiler des octaves

Un noise seul a une seule taille de détail. La nature, non : une montagne a des crêtes, puis des rochers, puis des cailloux. On empile donc plusieurs copies du même noise, de plus en plus petites et de plus en plus faibles. C'est le fBm (fractional Brownian motion). Dans Houdini, c'est l'onglet Fractal.

• Max Octaves : combien de couches. Chaque octave coûte un calcul complet de plus.
• Lacunarity : combien la fréquence est multipliée à chaque couche (2 = deux fois plus petit à chaque fois).
• Roughness : combien l'amplitude est multipliée à chaque couche (0.5 = deux fois plus faible). Près de 1 = très rugueux, près de 0 = lisse.

Fractal Type change la façon d'additionner :

• Standard : on additionne tout, partout pareil.
• Terrain : le détail ajouté est multiplié par la valeur actuelle. Les vallées (valeurs basses) restent lisses, les sommets deviennent accidentés. Comme un vrai relief érodé.
• Hybrid : proche de Terrain, avec des vallées plus marquées.

Un détail qui compte en FX : le détail plus petit que l'espacement de tes points est perdu, voire se transforme en grésillement (aliasing). 8 octaves sur une grille de 100×100 points, c'est du calcul pour rien. Houdini arrête d'ailleurs d'ajouter des octaves quand il n'y a « plus de place » pour le détail.

Lacunarity = de combien ça rétrécit. Roughness = de combien ça s'affaiblit. Octaves = combien de fois.

Perlin, Simplex et Fast Simplex Cloud

Les trois derniers types du menu viennent de la Cloud Noise VOP (Houdini 20+). Ce sont des fractals avec une astuce en plus : à chaque octave, la position de lecture est décalée selon la pente de l'octave précédente. Les petits détails « glissent » autour des gros volumes, ce qui donne des bords gonflés et cotonneux, comme un cumulus.

• Distortion : la force et le sens de ce décalage. Positif : vers les valeurs décroissantes ; négatif : vers les valeurs croissantes. Compare −1, 0 et +1 ci-contre.
• Perlin Cloud : base Perlin. Simplex Cloud : base Simplex, moins d'alignements. Fast Simplex Cloud : autre structure de grille et accumulation moins chère, pour les gros volumes.
• Dans l'Attribute Noise, ces types débloquent aussi Stretch, Droop (faire « pendre » le noise dans une direction) et Worley Details (ajouter des puffs Worley). À essayer sur un volume de densité.

Cloud = fractal + chaque couche déformée par la précédente → formes de nuage.

Le fractal Perlin à la main, en VEX

Ce que fait l'Attribute Noise en mode Standard, en simplifié. À coller dans un Point Wrangle, puis cliquer sur le bouton « Create spare parameters ».

// Point Wrangle : displacement fractal le long de N
vector pos = v@rest / chf("element_size") + chv("offset");
float n = 0, amp = 1;
for (int i = 0; i < chi("octaves"); i++) {
    n   += amp * (noise(pos) - 0.5); // Perlin centré sur 0
    pos *= chf("lacunarity");        // ex. 2 : détail 2× plus petit
    amp *= chf("roughness");         // ex. 0.5 : 2× plus faible
}
@P += @N * n * chf("amp");

Worley F2 − F1 et couleur par cellule

Base de fissures, d'écailles ou de pré-fracture.

// Point Wrangle
int   seed;
float f1, f2;
wnoise(v@P * chf("freq"), seed, f1, f2);
f@cracks = f2 - f1;   // 0 sur les frontières
@Cd      = rand(seed); // une couleur par cellule
// Manhattan : mwnoise()   Chebyshev : cwnoise()