Texture procédurale

Le filtre Texture procédurale permet d’effectuer diverses manipulations de pixels en appliquant des fonctions prédéterminées et des variables utilisateur. Il est possible de composer vos propres filtres à partir de paramètres configurables.

Avant
Après
Avant et après. Une texture de relief est créée à partir d’une carte normale utilisant des fonctions point et debump, puis un mode de fusion Lumière tamisée est utilisée pour « raviver » un rendu 3D.

À propos du filtre Texture procédurale

Ce filtre peut être appliqué comme filtre dynamique non destructif. Il est accessible via le menu Calque, dans la catégorie Nouveau calque de filtre dynamique.

Paramètres

Les paramètres suivants peuvent être modifiés dans la zone de dialogue Filtre :


Utiliser le filtre

Le filtre comporte plusieurs composants clés que vous devez comprendre pour l’utiliser efficacement :


Exemples

Voici quelques exemples pratiques illustrant la façon dont le filtre de texture procédurale peut être utilisé. Les variables de saisies personnalisées sont surlignées en gras. Pour les suivre, copiez et collez la ligne de code dans une nouvelle ligne d’équation, définissez des canaux cibles si nécessaire, puis créez des saisies personnalisées en vous appuyant sur les entrées du tableau.

Vignette ronde

Vignette
var vignettew=vec2(rx, ry)/w; var vignetteh=vec2(rx, ry)/h; var productw=oscsc(vignettew); var producth=oscsc(vignetteh); scurveinterp(productw, producth, roundness)*(intensity*imultiplier)

Cibler les trois canaux (R, V et B). Utiliser un mode de fusion tel qu’Écran.

Type de saisie personnalisée Nom de variable Explication
Saisie de plage [0,1] roundness Utilisé comme variable dans scurveinterp pour contrôler l’arrondi de la vignette.
Saisie de plage [0,1] intensité Cette valeur est multipliée par le résultat scurveinterp pour modifier l’intensité (luminosité) de la vignette.
Saisi de nombres réels imultiplier Ce nombre réel est multiplié par la valeur intensity afin de la mettre à l’échelle, produisant une plage plus large de luminosité réalisable.

Cette expression comporte quatre déclarations de variable – rx et ry sont utilisées pour créer deux résultats vectoriels : vignettew et vignetteh. Les résultats vectoriels sont divisés par la largeur et la hauteur, respectivement. Nous calculons ensuite productw et producth à l’aide d’oscillateurs à courbe en S (oscsc). Enfin, nous interpolons entre deux résultats de produit à l’aide d’un interpolant à courbe en S (scurveinterp). Le mélange entre les deux résultats est contrôlé par la saisie personnalisée roundness et la luminosité est mise à l’échelle par les saisies personnalisées intensity et imultiplier.

Comme rx et ry (positions X et Y relatives) sont utilisées pour la création vectorielle, l’utilisateur peut cliquer-faire le pointeur sur le canevas pour déterminer le point central (origine) de la vignette.

Lorsque le filtre est utilisé avec un mode de fusion approprié (version Filtre dynamique recommandée), un effet de vignette adapté peut être obtenu.

Masque alpha losange

Vignette
var v=vec2(rx,ry)/w; smoothoschlin(oschcr(v/(dsize*dmult)), dsmooth)

Cibler uniquement le canal alpha (A).

Type de saisie personnalisée Nom de variable Explication
Saisie de plage [0,1] dsmooth Contrôle le lissage des bords de masque.
Saisie de plage [0,1] dsize Détermine la taille du masque.
Saisi de nombres réels dmult Met à l’échelle dsize avec un multiplicateur pour permettre des tailles de masque plus/moins grandes.

Nous assignons ici le résultat de la création vectorielle en utilisant rx et ry à la variable v (divisant le résultat par la largeur de document, w). Le résultat v est ensuite soumis à un oscillateur harmonique avec un courbe Catmull-Rom (oschcr), elle-même ensuite soumise à un oscillateur harmonique lisse (smoothoschlin). Dans la fonction oschcr, v est divisé par dsize*dmult, qui contrôle la taille globale. dsmooth est utilisé dans la fonction smoothoschlin pour influencer le lissage et le flou des bords. Lorsque le canal cible est défini sur alpha (A), cette expression crée un effet de masque alpha losange.

Comme rx et ry (positions X et Y relatives) sont utilisées pour la création vectorielle, l’utilisateur peut cliquer-faire le pointeur sur le canevas pour modifier la position de l’effet de masque.


Fonctions

Ci-dessous un tableau des fonctions pouvant être utilisées dans la section Équations, où :

Lorsqu’une fonction comporte des arguments T ou V, la taille de vecteur doit être la même pour tous les arguments. Ils ne sont pas interchangeables.

Fonction Utilisation Remarques
Mathématiques élémentaires
abs abs(T) Arrondir la valeur à l’entier absolu
acos acos(T)
asin asin(T)
atan atan(T)
atan2 atan2(T, T)
moyen average(T, T, ...) (arguments de variable)
ceil ceil(T) Arrondir la valeur
copysign copysign(T, T sign)
cos cos(T)
dim dim(T x, T y)
floor floor(T) Arrondir à la valeur inférieure
fma fma(T a, T b, T c) Calcule (a*b) + c
fmod fmod(T, T)
fraction fraction(T)
idiv idiv(T, T)
irem irem(T, T)
lerp lerp(T a, T b, T t) Linéaire interpole deux valeurs, équilibre déterminé par t entre 0-1
max max(T, T, ...) (arguments de variable)
mid mid(T, T)
min min(T, T, ...) (arguments de variable)
mix mix(T a, T b, T t) Identique à lerp
pow pow(T x, T y) x puissance y
powr powr(T x, T y) x puissance yx>0
round round(T)
roundup roundup(T)
rounddown rounddown(T)
sign sign(T)
sin sin(T)
sq sq(T)
sqrt sqrt(T) Racine carrée
tan tan(T)
trunc trunc(T) Abréviation de truncate (tronquer)
truncate truncate(T)
rgbtoi rgbtoi(S r, S g, Sb) ou rgbtoi(V rgb)
whole whole(T)
Conversion de plage numérique
tocui tocui(T) Intervalle fermé entre 0 et 1
tohcui tohcui(T) Intervalle fermé entre -1 et 1 (harmonique)
Limitation
saturer saturate(T)
clamp clamp(T) ou clamp(T, T min, T max)
clampmin clampmin(T, T min)
clampmax clampmax(T, T max)
Fonctions géométriques
cross cross(V3, V3) Calculer le produit vectoriel de deux composants Vector3 (XYZ)
dist dist(V a, V b) Abréviation de distance
dist_sq dist_sq(V a, V b) Abréviation de distance_squared
distance distance(V a, V b)
distance_squared distance_squared(V a, V b)
dot dot(V, V)
length length(V) ou length(S, S, ...)
length_squared length_squared(V) ou length_squared(S, S, ...)
norm norm(V) Abréviation de normalize (normaliser)
normalise normalise(V)
normalize normalize(V)
Création vectorielle
vec2 vec2(S) ou vec2(S, S) Convient pour la création de vecteurs à partir des positions XY, p. ex. vec2(rx, ry)
vec3 vec3(S) ou vec3(S, S, S) Permet de créer des vecteurs à partir de données de couleur, p. ex. vec3(R, G, B)
vec4 vec4(S) ou vec4(S, S, S, S)
vec5 vec5(S) ou vec5(S, S, S, S, S)
vec6 vec6(S) ou vec6(S, S, S, S, S, S)
tovec3 tovec3(V)
tovec4 tovec4(V)
tovec5 tovec5(V)
tovec6 tovec6(V)
Manipulation de vecteurs
rev rev(V)
rotl rotl(V) Rotation de vecteur vers la gauche
rotr rotr(V) Rotation de vecteur vers la droite
swap12 swap12(V)
swap13 swap13(V)
swap23 swap23(V)
swapxy swapxy(V)
swapxz swapxz(V)
swapyz swapyz(V)
swaprg swaprg(V)
swaprb swaprb(V)
swapgb swapgb(V)
neg1 neg1(V)
neg2 neg2(V)
neg3 neg3(V)
neg12 neg12(V)
negx negx(V)
negy negy(V)
negz negz(V)
negxy negxy(V)
negr negr(V)
negg negg(V)
negb negb(V)
negrg negrg(V)
Fonctions vectorielles
debump debump(S r, S g, S b)
Interpolation
scurveinterp scurveinterp(T a, T b, T t)
sininterp sininterp(T a, T b, T t)
cubicinterp cubicinterp(T a, T b, T c, T d, T t)
scurveinterpolant scurveinterpolant(T cui)
sininterpolant sininterpolant(T cui)
scerp scerp(T a, T b, T t) Abréviation de scurveinterp
serp serp(T a, T b, T t) Abréviation de sininterp
cerp cerp(T a, T b, T c, T d, T t) Abréviation de cubicinterp
cubic scerp(T a, T b, T c, T d, T t) Abréviation de cubicinterp
scint scint(T cui) Abréviation de scurverinterpolant
sint sint(T cui) Abréviation de sininterpolant
Étapes
mapcui mapcui(T v, T edge0, T edge1)
step step(T edge, T v)
stepn stepn(T edge, T v)
smoothsteplin smoothsteplin(T edge0, T edge1, T v) ou smoothsteplin(T in0, T in1, T out1, T out0, T v)
smoothstep smoothstep(T edge0, T edge1, T v) ou smoothstep(T in0, T in1, T out1, T out0, T v)
smoothstepsc smoothstepsc(T edge0, T edge1, T v) ou smoothstepsc(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) ou smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepcs smoothstepcs(T edge0, T edge1, T v) ou smoothstepcs(T in0, T in1, T out1, T out0, T v)
smoothstepsq smoothstepsq(T edge0, T edge1, T v) ou smoothstepsq(T in0, T in1, T out1, T out0, T v)
smoothstepsqi smoothstepsqi(T edge0, T edge1, T v) ou smoothstepsqi(T in0, T in1, T out1, T out0, T v)
smoothstepcb smoothstepcb(T edge0, T edge1, T v) ou smoothstepcb(T in0, T in1, T out1, T out0, T v)
smoothstepcbi smoothstepcbi(T edge0, T edge1, T v) ou smoothstepcbi(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) ou smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepsini smoothstepsini(T edge0, T edge1, T v) ou smoothstepsini(T in0, T in1, T out1, T out0, T v)
smoothstepcr smoothstepcr(T edge0, T edge1, T v) ou smoothstepcr(T in0, T in1, T out1, T out0, T v)
smoothstepcri smoothstepcri(T edge0, T edge1, T v) ou smoothstepcri(T in0, T in1, T out1, T out0, T v)
smoothsteprt smoothsteprt(T edge0, T edge1, T v) ou smoothsteprt(T in0, T in1, T out1, T out0, T v)
smoothsteprti smoothsteprti(T edge0, T edge1, T v) ou smoothsteprti(T in0, T in1, T out1, T out0, T v)
smoothstepnlin smoothstepnlin(T edge1, T edge0, T v)
smoothstepn smoothstepn(T edge1, T edge0, T v)
smoothstepnsc smoothstepnsc(T edge1, T edge0, T v)
smoothstepnsin smoothstepnsin(T edge1, T edge0, T v)
smoothstepncs smoothstepncs(T edge1, T edge0, T v)
smoothstepnsq smoothstepnsq(T edge1, T edge0, T v)
smoothstepnsqi smoothstepnsqi(T edge1, T edge0, T v)
smoothstepncb smoothstepncb(T edge1, T edge0, T v)
smoothstepncbi smoothstepncbi(T edge1, T edge0, T v)
smoothstepnpsini smoothstepnpsini(T edge1, T edge0, T v)
smoothstepncr smoothstepncr(T edge1, T edge0, T v)
smoothstepncri smoothstepncri(T edge1, T edge0, T v)
smoothstepnrt smoothstepnrt(T edge1, T edge0, T v)
smoothstepnrti smoothstepnrti(T edge1, T edge0, T v)
Quantification
quantize quantize(T band, T v) ou quantize(T band, T smooth, T v)
quantizelin quantizelin(T band, T smooth, T v)
quantizesc quantizesc(T band, T smooth, T v)
quantizesin quantizesin(T band, T smooth, T v)
quantizecs quantizecs(T band, T smooth, T v)
Oscillateurs
osci osci(S)
osci(S, S)
osci(V2)
Oscillation standard, saisies scalaires ou vectorielles acceptées
oscsc oscsc(S)
oscsc(S, S)
oscsc(V2)
Oscillateur avec courbe en S
oscsin oscsin(S)
oscsin(S, S)
oscsin(V2)
osccs osccs(S)
osccs(S, S)
osccs(V2)
osccubic osccubic(S)
osccubic(S, S)
osccubic(V2)
oscsq oscsq(S)
oscsq(S, S)
oscsq(V2)
oscsqi oscsqi(S)
oscsqi(S, S)
oscsqi(V2)
osccb osccb(S)
osccb(S, S)
osccb(V2)
osccbi osccbi(S)
osccbi(S, S)
osccbi(V2)
oscpsin oscpsin(S)
oscpsin(S, S)
oscpsin(V2)
oscpsini oscpsini(S)
oscpsini(S, S)
oscpsini(V2)
osccr osccr(S)
osccr(S, S)
osccr(V2)
osccri osccri(S)
osccri(S, S)
osccri(V2)
oscrt oscrt(S)
oscrt(S, S)
oscrt(V2)
oscrti oscrti(S)
oscrti(S, S)
oscrti(V2)
smoothosclin smoothosclin(S, S smoothingwidth)
smoothosclin(S, S, S smoothingwidth)
smoothosclin(V2, S smoothingwidth)
smoothosc smoothosc(S, S smoothingwidth)
smoothosc(S, S, S smoothingwidth)
smoothosc(V2, S smoothingwidth)
smoothoscsc smoothoscsc(S, S smoothingwidth)
smoothoscsc(S, S, S smoothingwidth)
smoothoscsc(V2, S smoothingwidth)
smoothoscsin smoothoscsin(S, S smoothingwidth)
smoothoscsin(S, S, S smoothingwidth)
smoothoscsin(V2, S smoothingwidth)
smoothosccs smoothosccs(S, S smoothingwidth)
smoothosccs(S, S, S smoothingwidth)
smoothosccs(V2, S smoothingwidth)
Oscillateurs harmoniques
oschi oschi(S)
oschi(S, S)
oschi(V2)
osch osch(S)
osch(S, S)
osch(V2)
oschsc oschsc(S)
oschsc(S, S)
oschsc(V2)
oschsin oschsin(S)
oschsin(S, S)
oschsin(V2)
oschcs oschcs(S)
oschcs(S, S)
oschcs(V2)
oschcubic oschcubic(S)
oschcubic(S, S)
oschcubic(V2)
oschsq oschsq(S)
oschsq(S, S)
oschsq(V2)
oschsqi oschsqi(S)
oschsqi(S, S)
oschsqi(V2)
oschcb oschcb(S)
oschcb(S, S)
oschcb(V2)
oschcbi oschcbi(S)
oschcbi(S, S)
oschcbi(V2)
oschhsin oschhsin(S)
oschhsin(S, S)
oschhsin(V2)
oschhsini oschhsini(S)
oschhsini(S, S)
oschhsini(V2)
oschcr oschcr(S)
oschcr(S, S)
oschcr(V2)
oschcri oschcri(S)
oschcri(S, S)
oschcri(V2)
oschrt oschrt(S)
oschrt(S, S)
oschrt(V2)
oschrti oschrti(S)
oschrti(S, S)
oschrti(V2)
smoothoschlin smoothoschlin(S, S smoothingwidth)
smoothoschlin(S, S, S smoothingwidth)
smoothoschlin(V2, S smoothingwidth)
smoothosch smoothosch(S, S smoothingwidth)
smoothosch(S, S, S smoothingwidth)
smoothosch(V2, S smoothingwidth)
smoothoschsc smoothoschsc(S, S smoothingwidth)
smoothoschsc(S, S, S smoothingwidth)
smoothoschsc(V2, S smoothingwidth)
smoothoschsin smoothoschsin(S, S smoothingwidth)
smoothoschsin(S, S, S smoothingwidth)
smoothoschsin(V2, S smoothingwidth)
smoothoschcs smoothoschcs(S, S smoothingwidth)
smoothoschcs(S, S, S smoothingwidth)
smoothoschcs(V2, S smoothingwidth)
Bruit simple
noisei noisei(S)
noisei(S, S)
noisei(S, S, S)
noisei(V2)
noisei(V3)
noise noise(S)
noise(S, S)
noise(S, S, S)
noise(V2)
noise(V3)
Bruit linéaire
noisesc noisesc(S)
noisesc(S, S)
noisesc(S, S, S)
noisesc(V2)
noisesc(V3)
Bruit de courbe en S
noisesin noisesin(S)
noisesin(S, S)
noisesin(S, S, S)
noisesin(V2)
noisesin(V3)
noisecs noisecs(S)
noisecs(S, S)
noisecs(S, S, S)
noisecs(V2)
noisecs(V3)
noisecubic noisecubic(S)
noisecubic(S, S)
noisecubic(S, S, S)
noisecubic(V2)
noisecubic(V3)
noisesq noisesq(S)
noisesq(S, S)
noisesq(S, S, S)
noisesq(V2)
noisesq(V3)
noisesqi noisesqi(S)
noisesqi(S, S)
noisesqi(S, S, S)
noisesqi(V2)
noisesqi(V3)
noisecb noisecb(S)
noisecb(S, S)
noisecb(S, S, S)
noisecb(V2)
noisecb(V3)
noisecbi noisecbi(S)
noisecbi(S, S)
noisecbi(S, S, S)
noisecbi(V2)
noisecbi(V3)
noisepsin noisepsin(S)
noisepsin(S, S)
noisepsin(S, S, S)
noisepsin(V2)
noisepsin(V3)
noisepsini noisepsini(S)
noisepsini(S, S)
noisepsini(S, S, S)
noisepsini(V2)
noisepsini(V3)
noisecr noisecr(S)
noisecr(S, S)
noisecr(S, S, S)
noisecr(V2)
noisecr(V3)
noisecri noisecri(S)
noisecri(S, S)
noisecri(S, S, S)
noisecri(V2)
noisecri(V3)
noisert noisert(S)
noisert(S, S)
noisert(S, S, S)
noisert(V2)
noisert(V3)
noiserti noiserti(S)
noiserti(S, S)
noiserti(S, S, S)
noiserti(V2)
noiserti(V3)
Bruit simple harmonique
noisehi noisehi(S)
noisehi(S, S)
noisehi(S, S, S)
noisehi(V2)
noisehi(V3)
noiseh noiseh(S)
noiseh(S, S)
noiseh(S, S, S)
noiseh(V2)
noiseh(V3)
noisehsc noisehsc(S)
noisehsc(S, S)
noisehsc(S, S, S)
noisehsc(V2)
noisehsc(V3)
noisehsin noisehsin(S)
noisehsin(S, S)
noisehsin(S, S, S)
noisehsin(V2)
noisehsin(V3)
noisehcs noisehcs(S)
noisehcs(S, S)
noisehcs(S, S, S)
noisehcs(V2)
noisehcs(V3)
noisehcubic noisehcubic(S)
noisehcubic(S, S)
noisehcubic(S, S, S)
noisehcubic(V2)
noisehcubic(V3)
noisehsq noisehsq(S)
noisehsq(S, S)
noisehsq(S, S, S)
noisehsq(V2)
noisehsq(V3)
noisehsqi noisehsqi(S)
noisehsqi(S, S)
noisehsqi(S, S, S)
noisehsqi(V2)
noisehsqi(V3)
noisehcb noisehcb(S)
noisehcb(S, S)
noisehcb(S, S, S)
noisehcb(V2)
noisehcb(V3)
noisehcbi noisehcbi(S)
noisehcbi(S, S)
noisehcbi(S, S, S)
noisehcbi(V2)
noisehcbi(V3)
noisehpsin noisehpsin(S)
noisehpsin(S, S)
noisehpsin(S, S, S)
noisehpsin(V2)
noisehpsin(V3)
noisehpsini noisehpsini(S)
noisehpsini(S, S)
noisehpsini(S, S, S)
noisehpsini(V2)
noisehpsini(V3)
noisehcr noisehcr(S)
noisehcr(S, S)
noisehcr(S, S, S)
noisehcr(V2)
noisehcr(V3)
noisehcri noisehcri(S)
noisehcri(S, S)
noisehcri(S, S, S)
noisehcri(V2)
noisehcri(V3)
noisehrt noisehrt(S)
noisehrt(S, S)
noisehrt(S, S, S)
noisehrt(V2)
noisehrt(V3)
noisehrti noisehrti(S)
noisehrti(S, S)
noisehrti(S, S, S)
noisehrti(V2)
noisehrti(V3)
Bruit de Perlin
perlin perlin(S x, I octaves, S persistence)
perlin(S x, S y, I octaves, S persistence)
perlin(V2 pt, I octaves, S persistence)
perlinsc perlinsc(S x, I octaves, S persistence)
perlinsc(S x, S y, I octaves, S persistence)
perlinsc(V2 pt, I octaves, S persistence)
perlinsin perlinsin(S x, I octaves, S persistence)
perlinsin(S x, S y, I octaves, S persistence)
perlinsin(V2 pt, I octaves, S persistence)
perlincubic perlincubic(S x, I octaves, S persistence)
perlincubic(S x, S y, I octaves, S persistence)
perlincubic(V2 pt, I octaves, S persistence)
perlincs perlincs(S x, I octaves, S persistence)
perlincs(S x, S y, I octaves, S persistence)
perlincs(V2 pt, I octaves, S persistence)
Bruit de Perlin harmonique
perlinh perlinh(S x, I octaves, S persistence)
perlinh(S x, S y, I octaves, S persistence)
perlinh(V2 pt, I octaves, S persistence)
perlinhsc perlinhsc(S x, I octaves, S persistence)
perlinhsc(S x, S y, I octaves, S persistence)
perlinhsc(V2 pt, I octaves, S persistence)
perlinhsin perlinhsin(S x, I octaves, S persistence)
perlinhsin(S x, S y, I octaves, S persistence)
perlinhsin(V2 pt, I octaves, S persistence)
perlinhcubic perlinhcubic(S x, I octaves, S persistence)
perlinhcubic(S x, S y, I octaves, S persistence)
perlinhcubic(V2 pt, I octaves, S persistence)
perlinhcs perlinhcs(S x, I octaves, S persistence)
perlinhcs(S x, S y, I octaves, S persistence)
perlinhcs(V2 pt, I octaves, S persistence)
Bruit de Voronoï
cellnoise cellnoise(S x, S y)
cellnoise(S x, S y, S spread)
cellnoise2 cellnoise2(S x, S y, I degree)
cellnoisedist cellnoisedist(S x, S y)
cellnoisedist(S x, S y, S spread)
cellnoiseedge cellnoiseedge(S x, S y, S sz, S softness)
Bruit directionnel
diri diri(S)
diri(S, S)
diri(V2)
dir dir(S)
dir(S, S)
dir(V2)
dirsc dirsc(S)
dirsc(S, S)
dirsc(V2)
dirsin dirsin(S)
dirsin(S, S)
dirsin(V2)
dircs dircs(S)
dircs(S, S)
dircs(V2)
udiri udiri(S)
udiri(S, S)
udiri(V2)
udir udir(S)
udir(S, S)
udir(V2)
udirsc udirsc(S)
udirsc(S, S)
udirsc(V2)
udirsin udirsin(S)
udirsin(S, S)
udirsin(V2)
udircs udircs(S)
udircs(S, S)
udircs(V2)
dir3i dir3i(S)
dir3i(S, S)
dir3i(V2)
dir3 dir3(S)
dir3(S, S)
dir3(V2)
dir3sc dir3sc(S)
dir3sc(S, S)
dir3sc(V2)
dir3sin dir3sin(S)
dir3sin(S, S)
dir3sin(V2)
dir3cs dir3cs(S)
dir3cs(S, S)
dir3cs(V2)
udir3i udir3i(S)
udir3i(S, S)
udir3i(V2)
udir3 udir3(S)
udir3(S, S)
udir3(V2)
udir3sc udir3sc(S)
udir3sc(S, S)
udir3sc(V2)
udir3sin udir3sin(S)
udir3sin(S, S)
udir3sin(V2)
udir3cs udir3cs(S)
udir3cs(S, S)
udir3cs(V2)

VOIR AUSSI :