Custom Tool Node

Le Custom Tool évalue, pour chaque pixel de la sortie, des formules séparées pour R, G, B et A. Les formules peuvent référencer les pixels des inputs (in1-in8) à la même position ou à des positions custom, faire des calculs maths complexes, et utiliser des paramètres additionnels (n1-n8 numbers, p1-p8 points).

Beaucoup plus flexible que Channel Booleans (qui se limite à des opérations standards) ou Color Curves (qui mappe par canal sans interaction). Permet aussi le sampling à des positions arbitraires (utile pour distortions et warps custom).

• Effects Library : Tools > Misc > Custom Tool
• Ajout rapide : clic droit dans le Node Editor → Add Tool > Misc > Custom Tool

Variables de pixel

r1, g1, b1, a1 : valeurs RGBA du pixel à la même position dans Image 1. Idem pour in2-in8.

Variables de coordonnées

x, y : coordonnées normalisées du pixel (0-1). Permettent des effets positionnels.

Paramètres

n1-n8 : valeurs scalaires custom (sliders). p1-p8 : points 2D (positions x/y custom).

Sampling

getr1f(x, y)= R d' in1 à position x,y. Permet le sampling à des positions arbitraires (distortions, warps).

Outputs

Quatre formules : R Expression, G, B, A. Le résultat est le pixel sortie.

• Image 1 (orange) - entrée principale.
• Image 2 à 8 - entrées supplémentaires pour formules avec multiple inputs.

Inversion couleurs simple :
R = 1 - r1
G = 1 - g1
B = 1 - b1
A = a1

Mix entre deux images selon Number :
R = r1 * (1 - n1) + r2 * n1
G = g1 * (1 - n1) + g2 * n1
B = b1 * (1 - n1) + b2 * n1
A = a1

Vignette procédurale :
distance = sqrt((x - 0.5)^2 + (y - 0.5)^2)
factor = 1 - distance * n1
R = r1 * factor
...

Distortion warp simple :
offset_x = sin(y * 10) * n1
R = getr1f(x + offset_x, y)
G = getg1f(x + offset_x, y)
B = getb1f(x + offset_x, y)
A = a1

Différence absolue (debug) :
R = abs(r1 - r2)
G = abs(g1 - g2)
B = abs(b1 - b2)
A = a1

R / G / B / A Expressions

Formule par canal. Chaque expression évaluée à chaque pixel pour produire le canal correspondant en sortie.

Number Controls (n1-n8)

Sliders custom paramétrables. Animer pour effets temporels. Référencables dans les expressions.

Point Controls (p1-p8)

Points 2D custom. Manipulables dans le viewer. Utiles pour des effets centrés sur position (spotlight virtuel).

Setup (intermediate)

Expressions intermédiaires exécutées une fois par évaluation, référencables dans R/G/B/A. Utile pour calculs partagés.

• Effet maths custom - effets que les nodes standards ne peuvent pas faire (formule particulière, condition complexe, calcul vectoriel).
• Combinaison non-standard d'images - blend custom (par exemple, mode alpha + multiply, ou opérations bit-à-bit), différence pondérée.
• Distortions warp custom - offset_x / offset_y calculé en fonction de paramètres = warp arbitraire (plus flexible que Displace).
• Debug visualisation - afficher différence entre deux versions, isoler un canal AOV pour visualisation.
• Prototypage de Fuses - tester un algorithme dans Custom Tool avant de le packaging en Fuse réutilisable.
• Mathématiques de compositing - pré-multiplication custom, chromaticity adjust, formules de gamut spécifiques.
• Effets stylisés procéduraux - vignettes complexes, fondus radiaux custom, motifs procéduraux maths.

• Performance - Custom Tool évalue par pixel. Pour 4K = 8M+ évaluations par frame. Coût significatif si les formules sont complexes.
• Setup pour calculs partagés - extraire dans Setup les calculs référencés dans plusieurs canaux pour les évaluer une fois.
• Coordonnées x, y normalisées - 0-1 indépendantes de la résolution. Mieux pour des effets robustes au redimensionnement.
• getr1f vs getr1 - getr1f = sampling bilinéaire (smooth), getr1= sampling exact pixel (pas d' interpolation). Préférer f pour warps lisses.
• Animer n1, p1 - les Number Controls sont animables. Permet effets temporels intégrés au Custom Tool.
• Documentation comment - les formules complexes deviennent vite illisibles. Utiliser des Sticky Notes à côté pour expliquer la formule mathématique.
• Préférer Fuse pour réutilisable - si on utilise le même Custom Tool sur plusieurs projets, le packager en Fuse pour partage et performance native.
• Pour des effets vraiment hardcore (multi-pass, convolutions complexes), passer directement aux Fuses (en C++ ou Lua).